Java 5.0 新特性

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java 5.0 新特性相关的知识,希望对你有一定的参考价值。

package com.fish.jdk15;
import java.util.ArrayList;
import java.util.Collections;
/*
 jdk1.5新特性之-------静态导入
 
 静态导入的作用: 简化书写。
 
静态导入可以作用一个类的所有静态成员(静态方法和静态成员变量)。 
 
 静态导入的格式:
 import static 包名.类名.静态的成员;
 
 
静态导入要注意的事项: 
 1. 如果静态导入的成员与本类的成员存在同名的情况下,那么默认使用本类的静态成员,如果需要指定使用静态导入的成员,那么需要在静态成员前面加上类名
 
 
 */
import static java.util.Collections.sort;
import static java.util.Collections.binarySearch;
import static java.util.Collections.max;
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(13);
        list.add(9);
        list.add(10);
        list.add(19);
        //排序
        sort(list);
        Collections.sort(list);
        out.println("集合的元素:"+ list);
        out.println("索引值:"+ binarySearch(list,13));
        out.println("最大值:"+ max(list));
    }
    public static void sort(ArrayList<Integer> list){
        System.out.println("本类 的sort方法.....");
    }
}


package com.fish.jdk15;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/*
jdk1.5出现的新特性---->增强for循环
增强for循环的作用: 简化迭代器的书写格式。(注意:增强for循环的底层还是使用了迭代器遍历。)
增强for循环的适用范围: 如果是实现了Iterable接口的对象或者是数组对象都可以使用增强for循环。
增强for循环的格式:
 
 for(数据类型  变量名  :遍历的目标){
 
 }
增强for循环要注意的事项:
1. 增强for循环底层也是使用了迭代器获取的,只不过获取迭代器由jvm完成,不需要我们获取迭代器而已,所以在使用增强for循环变量元素的过程中不准使用集合
对象对集合的元素个数进行修改。
2. 迭代器遍历元素与增强for循环变量元素的区别:使用迭代器遍历集合的元素时可以删除集合的元素,而增强for循环变量集合的元素时,不能调用迭代器方的法
3. 普通for循环与增强for循环的区别:普通for循环可以没有变量的目标,而增强for循环一定要有变量的目标。
4、增强for循环不能控制循环的次数
 
 */
 
public class Demo2 {
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<String>();
        
        //添加元素
        set.add("狗娃");
        set.add("狗剩");
        set.add("铁蛋");
        /*
        
        //使用迭代器遍历Set的集合.
        Iterator<String> it  = set.iterator();
        
        while(it.hasNext()){
            String temp = it.next();
            System.out.println("元素:"+ temp);
            it.remove();
        }
        
        //使用增强for循环解决
        for(String item : set){
            System.out.println("元素:"+ item);
            set.remove("狗剩"); //不能对集合的元素进行修改
        }
        
        int[] arr = {12,5,6,1};
         
         //普通for循环的遍历方式
        for(int i =  0 ; i<arr.length ; i++){
            System.out.println("元素:"+ arr[i]);
        }
        
        //使用增强for循环实现
        for(int item :arr){
            System.out.println("元素:"+ item);
        }
        
        //需求: 在控制台打印5句hello world.
        for(int i = 0 ; i < 5; i++){
            System.out.println("hello world");
        }
        
        */
        
        //注意: Map集合没有实现Iterable接口,所以map集合不能直接使用增强for循环,如果需要使用增强for循环需要借助于Collection
        // 的集合。
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("001","张三");
        map.put("002","李四");
        map.put("003","王五");
        map.put("004","赵六");
        Set<Map.Entry<String, String>> entrys = map.entrySet();
        
        for(Map.Entry<String, String> entry  :entrys){
            System.out.println("键:"+ entry.getKey()+" 值:"+ entry.getValue());
        }
    }
}



package com.fish.jdk15;
import java.util.Iterator;
//自定一个类使用增强for循环
class MyList implements Iterable<String>{
    Object[] arr = new Object[10];
    int index = 0 ;//当前的指针
   
    public void add(Object o){
        arr[index++] = o;  // 1
    }
   
    public int size(){
        return index;
    }
    
    @Override
    public Iterator<String> iterator() {
        return new Iterator<String>() {
            int cursor  = 0;
            @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("王五");
        for(String item :list){
            System.out.println(item);
        }
    }
}




package com.fish.jdk15;
/*
jdk1.5新特性之------->可变参数
需求: 定义一个函数做加法功能(函数做几个数据 的加法功能是不确定)。
可变参数的格式:
数据类型... 变量名(只能是三个点)
可变参数要 注意的细节: 
1. 如果一个函数 的形参使用上了可变参数之后,那么调用该方法的时候可以传递参数也可以不传递参数。
2. 可变参数实际上是一个数组对象。
3. 可变参数必须位于形参中的最后一个参数。
4. 一个函数最多只能有一个可变 参数,因为可变参数要位于形参中最后一个位置上。
 
 */
public class Demo4 {
  public static void main(String[] args) {
            int[] arr = {1,2,45,6,7};
            /*System.out.println(arr);
            add(arr);*/
            add();
   }
        
   public static void add(int... arr){ //长度是0
        System.out.println(arr);
        System.out.println("arr是一维数组吗?"+(arr instanceof int[]));
        System.out.println("长度"+arr.length);
        int result = 0;
        
        for(int item : arr){
            result+=item;
        }
        System.out.println("总和:"+ result);
   }
   
   public static void add1(int[] arr){ //长度是0
        int result = 0;
        for(int item : arr){
            result+=item;
        }
        System.out.println("总和:"+ result);
    }
}



package com.fish.jdk15;
import java.util.ArrayList;
/*
 jdk1.5新特性之-----自动装箱与自动拆箱。
 
 java是面向对象 的语言,任何事物都可以使用类进行描述,sun就使用了
 一些类描述java中八种基本数据类型数据
 
 基本数据类型            包装类型
 byte       Byte
short        Short
int           Integer
long          Long 
float          Float
double         Double 
boolean        Boolean 
char          Character
基本数据类型数据有了对应 的包装 类型的好处:
1、能使用方法,变得更加的强大
 */
 
 
 
public class Demo5 {
    public static void main(String[] args) {
        String str = "12";
        //字符串转换成int类型数据。 可以把字符串转换成对应的数字
        int i = Integer.parseInt(str);
        System.out.println(i+1);
        
        //把数字转换成字符串
        System.out.println("把整数转换成对应 的字符串:"+Integer.toString(i));
        
        //把整数转换成对应的进制形式
        System.out.println("10的二进制:"+ Integer.toBinaryString(10));
        System.out.println("10的二进制:"+ Integer.toBinaryString(10));
        System.out.println("10的十六进制:"+ Integer.toHexString(10));
        
        //可以把字符串当成对应的进行数据帮你转换
        String data = "10";
        int a = Integer.parseInt(data, 2);
        System.out.println("a="+a);
        
        //集合: 集合是可以存储任意对象类型数据的容器。
        ArrayList list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        
        //自动装箱: 自动把java的基本数据类型数据转换成对象类型数据。
        int temp = 10;  //基本数据类型
        Integer b =temp; //把a存储的值赋予给b变量,自动装箱
        Integer b1 =new Integer(temp); //手动装箱
        
        //自动拆箱: 把引用类型的数据转换成基本类型的数据
        Integer c = new Integer(13);
        int d = c; //自动拆箱
        int d1=c.intValue(); //手动拆箱
        System.out.println(d);
        
        //引用的数据类型
        Integer e = 128;
        Integer f = 128; 
        
        //==用来比较内存地址
        System.out.println("同一个对象吗?"+(e==f)); // Integer类内部维护了缓冲数组,该缓冲数组存储的-128~127 这些数据在一个数组中。如果你获取的数据是落入到这个范围之内的,那么就直接从该缓冲区中获取对应的数据。
    }
}



package com.fish.jdk15;
/*
 jdk1.5新特性之-----枚举
 
 问题:某些方法所接收的数据必须是在固定范围之内的, 
 
解决方案: 这时候我们的解决方案就是自定义一个类,然后是私有化构造函数,在自定义类中创建本类的对象对外使用。
jdk1.5对以上问题提出了新的解决方案: 就是使用枚举类解决。
一些方法在运行时,它需要的数据不能是任意的,而必须是一定范围内的值,Java5以后可以直接使用枚举予以解决。
 比如: 方向 , 性别 、 季节 、 星期......
 
 
 */
/*//自定义一个性别类
class Gender{
String value; //持有变量,但是这个变量只能自己来复制,那构造方法就不能公开给别人
public static final Gender man = new Gender("男");
public static final Gender woman = new Gender("女");
private Gender(String value) { //不能new
this.value = value;
}
}*/
enum Gender{
    //man,woman  //重写了toString方法,Gender.man 返回的是man
    
    man("男"),woman("女"); //重写了toString方法,Gender.man 返回的是man
    private String value;
    
    private Gender(String value){
        this.value = value;
    }
   
    public String getValue(){
        return value;
    }
    
 }
 
class Person{
    private String name;
    private Gender sex;
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Gender getSex() {
        return sex;
    }
    public void setSex(Gender sex) {
        this.sex = sex;
    }
}

public class Demo6 {
    public static void main(String[] args) {
        Person p = new Person();
        p.setName("狗娃");
        p.setSex(Gender.woman);
       
        System.out.println("名字:"+ p.getName()+" 性别:"+ p.getSex()); //调用Gender 枚举    --> 名字:狗娃 性别:woman
        //System.out.println("名字:"+ p.getName()+" 性别:"+ p.getSex().value); //调用Gender类  --> 名字:狗娃 性别:女
        System.out.println("名字:"+ p.getName()+" 性别:"+ p.getSex().getValue()); //调用Gender 枚举   --> 名字:狗娃 性别:女
        System.out.println(Sex.man); //sex.man 类重写了toString方法
    }
}


package com.fish.jdk15;
/*
枚举:一些方法在运行时,它需要的数据不能是任意的,而必须是一定范围内的值,可以直接使用枚举予以解决。
枚举类的定义格式:
enum 类名{
//枚举值
}
枚举要注意的细节:
1. 枚举类也是一个特殊的类。
2. 枚举值默认的修饰符是public static final。 javap -c -l -private Sex 可以查看源代码
3. 枚举值就是是枚举值所属的类的类型, 然后枚举值是指向了本类的对象的。
4. 枚举类的构造方法默认的修饰符是private的。
5. 枚举类可以定义自己的成员变量与成员函数。
6. 枚举类可以自定义构造函数,但是构造函数的修饰符必须是private。
7. 枚举类可以存在抽象 的方法,但是枚举值必须要实现抽象 的方法。
8. 枚举值必须要位置枚举类 的第一个语句。
 */
//自定义一个枚举类
enum Sex{
    //dog,pig;
    
    //public static final Sex dog= new Sex();
    
    man("男"){
        @Override
        public void run() {
            System.out.println("男人在跑...");
        }
    },woman("女"){
        @Override
        public void run() {
            System.out.println("女人在跑...");
        }
    }; //枚举值
    
    String value; //成员 变量
    
    //public static final Sex man = new Sex();
    
    
    //构造函数
    private Sex(String  value){
        this.value = value;
    }
    
    
    //成员函数
    public void getValue(){
        System.out.println("value :"+ value);
    }
   
    public abstract void run(); //可以定义抽象函数
}


public class Demo7 {
    public static void main(String[] args) {
        Sex sex = Sex.man; //获取到了枚举类的对象
        sex.value = "男";
        sex.getValue();
        sex.run();
    }
}




package com.fish.jdk15;
/*
 switch适用的数据类型: byte \ char \short \ int \ String\枚举类型
 
 注意: 
 case语句后面跟的枚举值,只需要单写枚举值即可,不需要再声明该 枚举值是属于哪个枚举类的。
 
 
 
 */
//季节枚举类

enum Season{
    spring,summer,autumn,winter;
}

enum Person2{
    student,worker;
}


public class Demo8 {
    public static void main(String[] args) {
        Season season = Season.summer;
        switch(season){
            case spring:
                System.out.println("春天...");
                break;
            case summer:
                System.out.println("夏天...");
                break;
            case autumn:
                System.out.println("秋天...");
                break;
            case winter:
                System.out.println("冬天...");
                break;
        }
    }
}


本文出自 “小鱼的博客” 博客,谢绝转载!

以上是关于Java 5.0 新特性的主要内容,如果未能解决你的问题,请参考以下文章

Atitit..jdk java 各版本新特性 1.0 1.1 1.2 1.3 1.4 1.5(5.0) 1.

Redis 5.0 正式发布!一网打尽所有新特性!

JAVA: spring 5 新特性

带你了解Gradle 5.0 一些新特性

Atitit spring 3.0 3.1 3.2 4.0 4.3 5.0 新特性

ABP Framework 5.0 RC.1 新特性和变更说明