Java之JDK新特性

傻大头
131 阅读14分钟

JDK5

.0
新
特性
JDK5
中新增了很多新的
java
特性，
大致
如下
：
1、
静态导入
2
、
自动装箱
/
拆箱
3
、
增强
for
循环
4
、
可变参数
5
、
枚举
6
、
泛型
一、
静态导入
JDK 1.5
增加的静态导入语法用于导入类的某个静态属性或方法
，
使用静态导入可以
简化程序对类静态属性和方法的调用
。
1
、
什么是静态导入
是指可以
import
类的静态方法和静态变量，在使用时
无须指定类名
便可以使用这些被
import
的静态方法和静态变量，这就是静态导入
2
、
静态导入的好处
a)
写
import
语句时，可以定位到一个静态方法或静态变量（以前是定位到类）
b)
可以使用通配符（
*
）代表导入该类的所有静态方法和静态变量
c)
使用静态导入可以简化程序对类静态属性和方法的调用
3
、
语法
import static
包名
.
类名
.
静态属性
|
静态方法
|*
4、
注意
不允许静态方法和静态变量出现重名的情况
如果静态导入的成员与本类的方法同名，优先使用本类的成员，静态导入这时失效（和方法的参数无关，同名就会失效）
/********
静态导入过程演示
*******/
import static java.lang.Math.max; //
导入了
Math
的
max
方法
import static java.lang.Math.min; //
导入了
Math
的
min
方法
import static java.lang.Integer.*; //
导入了
Integer
的所有静态方法和静态属性
public class StaticImport {
public static void main(String[] args){
//
通过静态导入使用
Math
的静态方法
，这里不再是
Math.max(5,10)
了
System.out.println(max(5,10));
System.out.println(min(5,10));
//
通过静态导入使用
Integer
的静态方法
System.out.println(parseInt("55544555"));
System.out.println(toBinaryString(2354));
//
通过静态导入使用
Integer
的静态属性
System.out.println(MAX_VALUE);
System.out.println(MIN_VALUE);
}
}
二、
增强

for

循环
1
、
引入增强
for
循环的原因：
在
JDK5
以前的版本中，遍历数组或集合中的元素，需先获得数组的长度或集合的迭代器，比较麻烦！因此
JDK5
中定义了一种新的语法
——
增强
for
循环，以简化此类操作。
2
、
用法
增强
for
循环
只能
用在
数组
、或
实现
Iterable
接口的集合类
上
3
、
语法格式
for(
变量类型 变量　：需迭代的数组或集合
){}
4
、增强
for
循环的好处
是为了让你的代码变得简捷、和容易维护。
不过其运行
速度
跟
普通遍历的速度是一致的。
/********
增强
for
循环过程演示
*******/
import java.util.ArrayList;
import java.util.List;
/**
*
新的
for
循环
,
格式为
for(type x:type y)
*
表示遍历数组或集合
y
的元素
,
把元素值赋给
x
*/
public class ForEach {
/**
对整数数组求和
*/
public static long getSum(int[] nums) throws Exception{
if(nums == null)
throw new Exception("
错误的参数输入
,
不能为
null!"
);
long sum = 0;
//
依次取得
nums
元素的值并累加
for(int x : nums){
sum += x;
}
return sum;
}
/**
对整数列表求和
*/
public static long getSum(List<Integer> nums) throws Exception{
if(nums == null)
throw new Exception("
错误的参数输入
,
不能为
null!"
);
long sum = 0;
//
可以与遍历数组一样的方式遍历列表
for(int x:nums){
sum += x;
}
return sum;
}
/**
求多维数组的平均值
*/
public static int getAvg(int[][] nums) throws Exception{
if(nums == null)
throw new Exception("
错误的参数输入
,
不能为
null!"
);
long sum = 0;
long size = 0;
//
对于二维数组
,
每个数组元素都是一维数组
for(int[] x : nums){
//
一维数组中的元素才是数字
for(int y : x){
sum += y;
size ++;
}
}
return (int)(sum/size);
}
public static void main(String[] args) throws Exception {
int[] nums = {456,23,-739,163,390};
List<Integer> list_I = new ArrayList<Integer>();
for(int i = 0; i < 5; i++){
list_I.add(nums);
}
System.out.println(getSum(nums));
System.out.println(getSum(list_I));
int[][] numss = {{1,2,3},{4,5,6},{7,8,9,10}};
System.out.println(getAvg(numss));
}
}
三、
可变参数
1
、作用
在
J2SE5.0
之前
,
当传入到方法的参数个数不固定时
,
经常采用数组的方式传递参数
在
J2SE5.0
之后
,
可以使用可变参数的给方法传递参数
2
、语法
语法：数据类型
…
变量名
3
、细节
a)
声明：
在一个方法中，最多
只能
有一个可变参数。
可变参数
只能
放在参数列表的最后面。
b)
调用：
当使用可变参数时，可以传
0
或多个参数。
当使用可变参数时，也可以传一个数组进去，就表示多个参数。
c)
使用：
在方法内部使用时，就是在使用一个数组。
当调用时没有传参数时（传了
0
个），这时在方法内部的参数数组是有值的（不为
null
），但长度为
0
d)
特别强调：
一个方法里最多
只能
有一个变长参数
,
而且这个变长参数
一定要放
在参数表的
最后一个
参数
/********
静态导入过程演示
*******/
/**
*
在参数类型和参数名之间使用
"..."(
三个英文的点
),
表示该参数为可变长的
*
通过新的
for
循环读取可变长参数中的值
*/
import static java.lang.System.*;
public class VarArgs {
public static void print(Integer... s){
for(int s2:s){ //
解封
out.print(s2+"\t");
}
out.println();
}
public static void main(String... args) {
print(); //
调用
public static void print()
方法
print(1); //
调用
public static void print(
Integer i)
方法 封箱
print(2,3); //
调用
public static void print(
Integer... s)
方法 封箱
print(4,5,6);//
调用
public static void print(
Integer... s)
方法 封箱
}
}
4
、
自动装箱

/

拆箱
自动装箱：指开发人员可以把一个基本数据类型直接赋给对应的
包装类
。
自动拆箱：指开发人员可以把一个包装类对象直接赋给对应的
基本数据类型
。
1
、
JDK5.0
后出现了自动装箱和拆箱
，
简化了定义方式
Integer x = new Integer(5); //
装箱
int intValue = x.intValue(); //
拆箱
// 5.0
简化书写
自动装箱。
new Integer(5);
Integer y = 5;
//
对象加整数
,x
进行了自动拆箱
,
变成了
int
型 和
5
进行加法运算后再将和进行装箱赋给
x
。
y = y + 5; //
是通过
Integer.intValue()
方法进行拆箱
2
、需要注意的细节：
a) Integer
的缓存大小
在-128 ~127
之间也就是
byte
的范围。
b)
基本类型的数据值可以直接赋给基本数据对象
,
基本数据的对象也可以直接赋给基本数据变量
c)
在表达式中
,
基本类型的数据值可以和基本数据对象进行运算
d)
基本数据类型的数组不能实现自动装箱和拆箱
,
即
int[]
不能当成
Integer[]
使用
3
、
典型应用：
List list = new ArrayList();
list.add(1); //替换了 list.add(new Integer(1));
int i=list.get(0); //替换了 int j = (Integer)list.get(0);
5
、
基本数据类型包装类
包装类
基本数据类型
Byte
byte
Short
short
Integer
int
Long
long
Boolean
boolean
Float
float
Double
double
Character
char
对象变基本数据类型
:
拆箱
基本数据类型包装为对象
:
装箱
a) 目标：
为了使得
java
的基本类型有更多的功能，
java
为其所有的基本类型提供了包装类来封装常见的功能
。如：最大值、数值转换等
b) 好处：
将基本数据类型封装成对象的好处在于
可以在对象中定义更多的功能方法操作该数据
包装类
所属的包
为
：
java.lang.*
应用一
:
获取最大最小值
：MAX_VALUE / MIN_VALUE
整数类型最大值
：Integer.MAX_VALUE
System.out.println(Integer.MIN_VALUE); // -2147483648
System.out.println(Integer.MAX_VALUE); // 2147483647
应用二
:
基本数据类型和字符串之间的转换
1、
基本数据类型转换成字符串
: // Integer
的
parseInt
方法，
intValue
方法
a)
基本数据类型
+””
int i=100;
String str=100+"";
b)
基本数据类型
.toString(
基本数据类型值
);
String string = Integer.toString(100);
Integer.toString(34); //
将
34
变成了
”34”
2、
字符串变基本数据类型
：
a) 语法：
基本数据类型
a =
基本数据类型包装类
.parse
基本数据类型
(String str);
str="123";
int parseInt = Integer.parseInt(str);
System.out.println(parseInt);
double parseInt2 = Double.parseDouble(str);
boolean b = Boolean.parseBoolean("true");
注意
: Integer
类中的
parseInt
方法是静态的 参数必须是数字格式
// public static int parseInt(String s)
应用三
:
进制转换
:
1
、
十进制转成其他进制
toBinaryString(int i)
以二进制（基数
2
）无符号整数形式返回一个整数参数的字符串表示形式。
toHexString(int i)
以十六进制（基数
16
）无符号整数形式返回一个整数参数的字符串表示形式。
toOctalString(int i)
以八进制（基数
8
）无符号整数形式返回一个整数参数的字符串表示形式。
/********
演示十进制转成其他进制转换过程
*******/
//
十进制转二进制
String binaryString = Integer.toBinaryString(100);
System.out.println(binaryString); // 1100100
//
十进制转十六进制
String hexString = Integer.toHexString(100);
System.out.println(hexString); // 64
//
十进制转八进制
String octalString = Integer.toOctalString(100);
System.out.println(octalString); // 144
2
、
其他进制转成十进制
parseInt(String radix);
parseInt(String s, int radix)
使用第二个参数指定的基数，将字符串参数解析为有符号的整数。
/********
演示其他进制转十进制转换过程
*******/
//
字符串转对应的进制
int parseInt3 = Integer.parseInt(octalString);
System.out.println(parseInt3);
//
二进制转十进制
int parseInt4 = Integer.parseInt(binaryString, 2);
System.out.println(parseInt4);
//
十六进制转十进制
int parseInt5 = Integer.parseInt(hexString, 16);
System.out.println(parseInt5);
//
八进制转十进制
int parseInt6 = Integer.parseInt(octalString, 8);
System.out.println(parseInt6);

四、

枚举类
枚举类特别注意事项：
*enum
关键字表示枚举类型，它的作用相当于类声明中的
class
关键字
*
枚举类型不能有
public
的构造方法
*
所有的枚举值都是
public
、
static
、
final
的
,
这些修饰符都是自动加上
,
无须程序员手动添加
*
枚举值之间用逗号
","
分开
,
最后一个枚举值后面接分号
";"
*
每一个枚举值是一个枚举类型的实例
*
可以在枚举类型中定义非枚举值变量
,
这些变量可以使用任何修饰符
*
变量和方法的定义必须在枚举值后面定义
1
、枚举主要的
7
种方法
用法一：常量
在
JDK1.5
之前，我们
定义常量都是：
public static fianl....
。现在好了，有了枚举，可以把相关的常量分组到一个枚举类型里，而且枚举提供了比常量更多的方法。
public enum Color {
RED, GREEN, BLANK, YELLOW
}
用法二：
switch
JDK5
中扩展了
swith
语句，它除了可以接收
int, byte, char, short
外，
还可以接收一个枚举类型
(enum)
。
enum Signal {
GREEN, YELLOW, RED
}
public class TrafficLight {
Signal color = Signal.RED;
public void change() {
switch (color) {
case RED:
color = Signal.GREEN;
break;
case YELLOW:
color = Signal.RED;
break;
case GREEN:
color = Signal.YELLOW;
break;
}
}
}
用法三：向枚举中添加新方法
如果打算自定义自己的方法，那么
必须
在
enum
实例序列的最后添加一个分号。而且
Java
要求
必须先定义
enum
实例
。
public enum Color {
RED("
红色
"
, 1), GREEN("
绿色
"
, 2), BLANK("
白色
"
, 3), YELLO("
黄色
"
, 4);
//
成员变量
private String name;
private int index;
//
构造方法
private Color(String name, int index) {
this.name = name;
this.index = index;
}
//
普通方法
public static String getName(int index) {
// values()
： 返回
所有
Color
类型的数组
for (Color c : Color.values()) {
if (c.getIndex() == index) {
return c.name;
}
}
return null;
}
// get set
方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
}
用法四：覆盖枚举的方法
下面给出一个
toString()
方法覆盖的例子。
public class Test {
public enum Color {
RED("
红色
"
, 1), GREEN("
绿色
"
, 2), BLANK("
白色
"
, 3), YELLO("
黄色
"
, 4);
//
成员变量
private String name;
private int index;
//
构造方法
private Color(String name, int index) {
this.name = name;
this.index = index;
}
//
覆盖方法
@Override
public String toString() {
return this.index + "_" + this.name;
}
}
public static void main(String[] args) {
System.out.println(Color.RED.toString());
}
}
用法五：实现接口
所有的枚举都继承自
java.lang.Enum
类。
由于
Java
不支持多继承，所以枚举对象不能再继承其他类
。
public interface Behaviour {
void print();
String getInfo();
}
public enum Color implements Behaviour {
RED("
红色
"
, 1), GREEN("
绿色
"
, 2), BLANK("
白色
"
, 3), YELLO("
黄色
"
, 4);
//
成员变量
private String name;
private int index;
//
构造方法
private Color(String name, int index) {
this.name = name;
this.index = index;
}
//
接口方法
@Override
public String getInfo() {
return this.name;
}
//
接口方法
@Override
public void print() {
System.out.println(this.index + ":" + this.name);
}
}
用法六：使用接口组织枚举
public interface Food {
enum Coffee implements Food {
BLACK_COFFEE, DECAF_COFFEE, LATTE, CAPPUCCINO
}
enum Dessert implements Food {
FRUIT, CAKE, GELATO
}
}
用法七：关于枚举集合的使用
java.util.EnumSet
和
java.util.EnumMap
是两个枚举集合。
EnumSet
保证集合中的元素不重复
;EnumMap
中的
key
是
enum
类型，而
value
则可以是任意类型
。关于这个两个集合的使用就不在这里赘述，可以参考
JDK
文档
2
、
枚举和常量定义的区别
一、
通常定义常量方法
我们通常利用
public final static
方法定义的代码如下，分别用
1
表示红灯，
3
表示绿灯，
2
表示黄灯。
public class Light {
/*
红灯
*/
public final static int RED = 1;
/*
绿灯
*/
public final static int GREEN = 3;
/*
黄灯
*/
public final static int YELLOW = 2;
}
二、
枚举类型定义常量方法
枚举类型的简单定义方法如下，我们似乎没办法定义每个枚举类型的值。比如我们定义红灯、绿
灯和黄灯的代码可能如下：
public enum Light {
RED, GREEN, YELLOW;
}
我们只能够表示出红灯、绿灯和黄灯，但是具体的值我们没办法表示出来。别急，既然枚举类型提供了构造函数，我们
可以通过构造函数和覆写
toString
方法来实现
。首先给
Light
枚举类型增加构造方法，然后
每个枚举类型的值通过构造函数传入对应的参数
，同时覆写
toString
方法，在该方法中返回从构造函数中传入的参数，改造后的代码如下：
public enum Light {
//
利用构造函数传参
RED(1), GREEN(3), YELLOW(2);
//
定义私有变量
private int nCode;
//
构造函数，枚举类型只能为私有
private Light(int _nCode) {
this.nCode = _nCode;
}
@Override
public String toString() {
//
返回带指定名称的指定枚举类型的枚举常量
return String.valueOf(this.nCode);
}
}
3
、
完整示例代码
枚举类型的完整演示代码如下：
public class LightTest {
// 1.
定义枚举类型
public enum Light {
//
利用构造函数传参
RED(1), GREEN(3), YELLOW(2);
//
定义私有变量
private int nCode;
//
构造函数，枚举类型只能为私有
private Light(int _nCode) {
this.nCode = _nCode;
}
@Override
public String toString() {
return String.valueOf(this.nCode);
}
}
public static void main(String[] args) {
// 1.
遍历枚举类型
System.out.println("
演示枚举类型的遍历
......"
);
testTraversalEnum();
// 2.
演示
EnumMap
对象的使用
System.out.println("
演示
EnmuMap
对象的使用和遍历
....."
);
testEnumMap();
// 3.
演示
EnmuSet
的使用
System.out.println("
演示
EnmuSet
对象的使用和遍历
....."
);
testEnumSet();
}
/**
*
演示枚举类型的遍历
*/
private static void testTraversalEnum() {
// values()
： 返回枚举的所有枚举常量
Light[] allLight = Light.values();
for (Light aLight : allLight) {
System.out.println("
当前灯
name
：
"
+ aLight.name());
// ordinal()
： 返回枚举常量的序数（初始常量的序数为
0
）
System.out.println("
当前灯
ordinal
：
"
+ aLight.ordinal());
System.out.println("
当前灯：
"
+ aLight);
}
}
/**
*
演示
EnumMap
使用，
EnumMap
跟
HashMap
的使用差不多，只不过
key
要是枚举类型
*/
private static void testEnumMap() {
// 1.
定义
EnumMap
对象，
EnumMap
对象的构造函数需要参数传入
,
默认
key
的类
的类型
EnumMap<Light, String> currEnumMap = new EnumMap<Light, String>(
Light.class);
currEnumMap.put(Light.RED, "
红灯
"
);
currEnumMap.put(Light.GREEN, "
绿灯
"
);
currEnumMap.put(Light.YELLOW, "
黄灯
"
);
// 2.
遍历对象
for (Light aLight : Light.values()) {
System.out.println("[key=" + aLight.name() + ",value="
+ currEnumMap.get(aLight) + "]");
}
}
/**
*
演示
EnumSet
如何使用，
EnumSet
是一个抽象类，获取一个类型的枚举类型内容
*
可以使用
allOf
方法
*/
private static void testEnumSet() {
EnumSet<Light> currEnumSet = EnumSet.allOf(Light.class);
for (Light aLightSetElement : currEnumSet) {
System.out.println("
当前
EnumSet
中数据为：
"
+ aLightSetElement);
}
}
}
枚举扩展案例完美版
public class EnumType {
/**
人
Person
的枚举类型
*/
enum Person {
CHINESE, //
中国人
AMERICAN, //
美国人
ENGLISH; //
英国人
}
public static void main(String[] args) {
System.out.println("Persion
枚举值的数目
: " + Person.values().length);
//
遍历枚举类型中的所有值
System.out.println("Person
枚举值如下
: "
);
Person[] ps = Person.values(); //values()
方法返回
Person
类型的数组
for (Person p : ps) {
System.out.print(p + " "); //toString()
方法返回枚举值的名称
,
此处打印
CHINESE
AMERICAN ENGLISH
}
System.out.println();
Person p = Person.CHINESE;
//
比较枚举值
if (p == Person.CHINESE) {
System.out.println("p' value equals Person.CHINESE");
}
//
使用
valueOf
获得字符串描述的枚举值
p = Person.valueOf("AMERICAN");
//
在
switch
中使用枚举值
// switch
中可以放置的类型有
byte,short,int,char,enum,
注意没有
long
switch (p) {
case CHINESE:
System.out.println("p is Chinese");
break;
case AMERICAN:
System.out.println("p is American");
break;
case ENGLISH:
System.out.println("p is English");
break;
}
//
获得枚举值在枚举类型中声明的顺序
System.out.println("AMERICAN
的序号
: "
+ Person.AMERICAN.ordinal());
System.out.println("CHINESE
的序号
: "
+ Person.CHINESE.ordinal());
System.out.println("ENGLISH
的序号
: "
+ Person.ENGLISH.ordinal());
//
使用更复杂的枚举类型
ComplexPerson
ComplexPerson cp = ComplexPerson.CHINESE;
//
因为为
CHINESE
枚举值覆盖了
toString()
方法
,
所以调用的是
CHINESE
的
toString
方法
System.out.println("cp.toString(): " + cp);
cp = ComplexPerson.AMERICAN;
//
因为没有为
AMERICAN
枚举值覆盖
toString
方法
,
所以调用默认的
toSting
方法
cp = ComplexPerson.OTHER;
System.out.println("cp.getValue(): " + cp.getValue());
}
/**
一个更复杂的枚举类型
*/
enum ComplexPerson {
//
枚举值
// CHINESE
的
value
属性为
"
中国人
"
CHINESE("
中国人
"
) {
public String toString() {
return "
这是个中国人
"
;
}
},
AMERICAN("
美国 人
"
), ENGLISH("
英国人
"
) {
public String toString() {
return "
这是个英国佬
"
;
}
},
OTHER {
public String toString() {
return "
这是个其它国家的人
"
;
}
};
private String value = null; //
枚举类值的
value
属性
,
只能声明在枚举值的后面
//
默认的构造方法
ComplexPerson() {
value = "
其他人
"
;
}
//
带参数的构造方法
ComplexPerson(String value) {
this.value = value;
}
//
获取
value
属性
public String getValue() {
return this.value;
}
}

}

更多技术资讯可关注：gzitcast


avatar
文章
阅读
粉丝