jdk1.5的新特性之-------->静态导入
静态导入的作用：简化书写。
静态导入仅对于一个类的静态成员起作用、
静态导入的格式：
import static 包名.类名.静态成员;
静态导入要注意的实现：
- 如果静态导入的成员与本类的静态成员同名了，那么在本类中优先使用本类的静态成员， 如果要使用静态导入的方法，那么需要指定类名进行调用。
package cn.itcast.jdk15;
import java.util.ArrayList;
import java.util.Collections;
/*
import static java.util.Collections.sort;
import static java.util.Collections.max;
import static java.util.Collections.min;
*/
import static java.util.Collections.*;
import static java.lang.System.out;
public class Demo1 {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(19);
list.add(3);
list.add(23);
list.add(4);
//排序:(有本地同名的静态函数时,只有写全)
Collections.sort(list);
out.println("集合的元素："+ list);
out.println("集合 的最大值："+ max(list));
out.println("集合 的最小值："+ min(list));
out.println();
}
public static void sort(ArrayList<Integer> list){
System.out.println("哈哈，排序了...");
}
}
jdk1.5新特性之----- 增强for循环
增强for循环的主要作用是： 简化迭代器的书写格式。
增强for循环的格式：
for(元素的数据类型 变量名 : 遍历的目标){
}
使用增强for循环的前提： 只有实现了Iterable接口的对象或者是数组对象才能使用。
增强for循环要注意的细节：
- 增强for循环 的底层还是通过获取迭代器的方式进行遍历的，只不过不需要我们手动获取迭代器而已，所以在使用增强for循环的遍历元素 的过程中不准使用集合对象改变集合对象中的元素个数。
- 增强for循环与迭代器遍历的区别： 增强for循环只能用于遍历集合的元素，不能增删元素 。 而迭代器的遍历方式可以使用迭代器的方法增删元素。
- 增强for循环使用的时候必须要存在一个遍历的目标对象， 而普通的for循环可以不存在遍历的目标对象。
public class Demo2 {
public static void main(String[] args) {
HashSet<String> set = new HashSet<String>();
set.add("张三");
set.add("李四");
set.add("王五");
/* System.out.println("===========迭代器的遍历方式===========");
Iterator<String> it = set.iterator(); //使用迭代器
while(it.hasNext()){
String item = it.next();
System.out.print(item +",");
it.remove();
}
for(String item : set){ //遍历出来的每个元素都会交给item变量。
System.out.print(item+",");
}
int[] arr = {19,17,18,30};
//普通的for循环遍历
for(int i = 0 ; i<arr.length ; i++){
System.out.print(arr[i]+",");
}
//增强for循环
for(int item :arr){
System.out.print(item+",");
}
int[] arr2 = new int[5];
//在控制台打印5句hello world
for(int i = 0 ; i<5; i++){
System.out.println("hello world");
}
*/
TreeMap<Integer, String> tree = new TreeMap<Integer, String>();
tree.put(110, "张三");
tree.put(109, "李四");
tree.put(120, "王五");
tree.put(115, "赵六");
//使用增强for循环遍历map集合、。
Set<Entry<Integer, String>> entryes = tree.entrySet();
for(Entry<Integer, String> entry : entryes){
System.out.println("键："+entry.getKey()+" 值："+ entry.getValue());
}
}
}
jdk1.5新特性之----- 自定义类实现Iterable接口
实现了Iterable接口后就可以使用迭代功能啦!!!
//自定义一个集合类
class MyList implements Iterable<String>{
Object[] arr ;
int index = 0;//当前的索引值
public MyList(){
arr = new Object[10];
}
public void add(Object o){
int minLength = index+1;
ensureCapcity(minLength); //检查长度
arr[index++]= o;
}
//检查当前的长度是否够用，如果不够用自动拓展0.5倍。
public void ensureCapcity(int minLength){
if(minLength==arr.length){
int newLength = (int) (arr.length*1.5);
arr = Arrays.copyOf(arr, newLength);
}
}
@Override
public Iterator<String> iterator() {
return new Iterator<String>() {
int cursor; //游标
@Override
public boolean hasNext() {
return cursor!=index;
}
@Override
public String next() {
return (String) arr[cursor++];
}
@Override
public void remove() {
}
};
}
}
public class Demo3 {
public static void main(String[] args) {
MyList list = new MyList();
list.add("张三");
list.add("李四");
list.add("王五");
list.add("赵六");
for(String item :list){
System.out.println(item+",");
}
}
}
jdk1.5新特性之----- 自定义类实现Iterable接口
可变参数的格式：
数据类型... 变量名 //几个点必须要写的
可变参数要 注意的事项：
- 如果一个函数的形参使用了可变参数，那么调用该函数的时候可以传递参数也可以不传递参数。
- 可变参数实际上就是一个数组.
- 可变参数必须要位于形参列表中的最后一个位置。
- 一个方法中最多只能使用一个可变参数。
需求:定义函数计算总和
public class Demo4 {
public static void main(String[] args) {
sum(1,2); //当一个函数使用了可变参数的时候，传递的数据的时候，jvm会自动把实参数据保存到一个数组中，然后再传递给可变参数。
}
public static void sum(int... arr){
int sum = 0;
for(int i : arr){
sum+=i;
}
System.out.println("总和："+ sum);
}
}
jdk1.5新特性之---自动装箱与自动拆箱
java是面向对象的语言， 任何的事物都使用了一个类进行了描述。 基本类型数据也是一类事物，所以
java对于基本类型的数据也使用了对应的类进行了描述，我们把描述基本类型变量的类称作为----- 包装类。
| 基本数据类型 | 包装类型 |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| boolean | Boolean |
| char | Character |
***基本数据类型设计出对应的包装类型的好处： *** 可以让基本数据类型也使用上方法，让功能变得更加强大。
public class Demo5 {
public static void main(String[] args) {
/*String str = "12";
//功能一：可以把字符串转成数字
int num = Integer.parseInt(str);
System.out.println(num+1);
//功能2： 可以把数字转成指定进制格式的字符串。
int num2 = 10;
System.out.println("二进制："+ Integer.toBinaryString(num2));
System.out.println("八进制："+ Integer.toOctalString(num2));
System.out.println("十六进制："+ Integer.toHexString(num2));*/
//自动装箱 -- 自动把基本数据类型转成引用数据类型数据，
/*ArrayList<Integer> list = new ArrayList<Integer>();
list.add(1); // new Integer(数据)
list.add(2);
*/
//自动拆箱： 自动把引用数据类型数据转成 基本数据类型.
Integer i = new Integer(10); //引用数据类型数据
System.out.println(2+i); // intValue() 获取基本类型的数据
/*
Integer类内部维护了一个静态的数组，该数组内部存储了-128~127这些数据，当我们创建
一个Integer对象的时候，如果数据是落入到了-128~127这个范围之内，那么会直接从数组中
获取，而不会创建新的Integer对象。 ----------> 把一些常用的数据事先创建好，
然后贡献给大家一起使用 ： 享元模式。
*/
Integer i1 = 127;
Integer i2 = 127;
System.out.println(i1==i2);//true;在int表示范围内,所以比较的其实是两个int数据而已
Integer ii1 = 128;
Integer ii2 = 128;
System.out.println(ii1==ii2)//false;因为超出了int表示的范围,所以这里是创建了两个不同对象
}
}
jdk1.5的新特性之-------->枚举类
枚举类的应用场景：一些方法在运行时，它需要的数据不能是任意的，而必须是一定范围内的值 , 这时候我们就可以使用枚举类进行限制。
比如： 一年四季、 方向、 性别...
定义枚举类的格式：
enum 类名{
}
枚举类要注意的事项：
- 枚举类是一个特殊的类。
- 枚举值默认的修饰符是： public static final 。
- 枚举值其实就是一个当前枚举类的对象。
- 枚举值必须是枚举类中的第一个语句。
- 枚举类的构造方法默认的修饰符是private，修饰符也必须是private.
- 枚举类允许出现抽象的方法，但是一旦出现了抽象的方法，那么枚举值就必须要实现抽象方法。(几乎不用)
enum Direction{
/*UP("上"){
@Override
public void test() {
System.out.println("哈哈，爽吗?");
}
},DOWN("下"){
@Override
public void test() {
System.out.println("呵呵，是向下！！");
}
}; */ //枚举值
UP("上"),DOWN("下");
String value; //成员变量
private Direction(String value){
this.value = value;
}
//成员函数
public void print(){
System.out.println("value:"+value);
}
//public abstract void test();
}
public class Demo7 {
public static void main(String[] args) {
//Direction.UP.test();使用抽象方法
Direciton.DOWN.print();
//使用values方法可以使用该枚举类的所有枚举值
Direction []d = Direction.values();
for(Direction value :d){
System.out.println(value);
}
}
}
switch语句的使用
switch语句适用的数据类型： byte\ short \ int \char \ String \枚举类型。
注意的事项：
- 在switch语句中使用枚举类的时候，case语句后面的枚举值不能带有枚举类，直接写枚举值即可。
//季节
enum Season{
SPRING,SUMMER,AUTUMN,WINTER;
}
public class Demo8 {
public static void main(String[] args) {
Season currentSeason = Season.SUMMER;
switch (currentSeason) {
case SPRING:
System.out.println("春天来了..");
break;
case SUMMER:
System.out.println("夏天到了..");
break;
case AUTUMN:
System.out.println("秋天不远了..");
break;
case WINTER:
System.out.println("冬天不见了..");
break;
}
}
}
