javase增强04

2022-07-15 19:04:09 作者：互联网

包装类

java为了实现一切皆对象，为8种基本数据类型提供了引用类型形式

集合和泛型也只能支持引用类型

自动拆箱
自动装箱

    /**
        学习包装类
     */
    public static void main(String[] args) {
        // 1、包装类和基本类型可以自动插箱，自动装箱
        Integer in = 11;
        int a = in;

        // 2、包装类可以转换成字符串
        String str = in.toString();
        String str2 = Integer.toString(11);

        // 3、字符串可以转换成包装类（重点）
        Integer inte = Integer.parseInt("123");
        Integer inte2 = Integer.valueOf("123");
    }

正则表达式

可以通过查询Pattern类学习正则表达式

Arrays 数组工具类

toString,sort,binary

    /**
     * 学习Arrays的 toString,sort,binary
     */
    public static void main(String[] args) {
        // 1、toString 对数组进行打印输出
        int[] ints = {1, 3, 5, 2};
        System.out.println(Arrays.toString(ints));//[1, 3, 5, 2]

        // 2、sort，只能对引用类型进行排序
        Integer[] intss = {1, 3, 5, 2};
        Arrays.sort(intss);
        System.out.println(Arrays.toString(intss));

        // 3、自定义sort排序规则，默认是升序排序
        Integer[] integer = {1,4,2,6,8,2};
        Arrays.sort(integer, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {

//                return Integer.compare(o1,o2);
                return o1 - o2;
            }
        });
        System.out.println(Arrays.toString(integer));

        // 4、对象排序
        Student[] students = new Student[3];
        students[0] = new Student("wang",12,222.33);
        students[1] = new Student("wang",11,222.33);
        students[2] = new Student("wang",14,222.33);
        // 需要重写toString方法 底层代码
        System.out.println(Arrays.toString(students));

        Arrays.sort(students, new Comparator<Student>() {
            // 升序排序：左边比右边大，返回正，右边比左边大，返回负
            @Override
            public int compare(Student o1, Student o2) {
//                return o1.getAge() - o2.getAge();
                return Double.compare(o1.getHeight(),o2.getHeight());
            }
        });
        System.out.println(Arrays.toString(students));
    }

Lambda 匿名函数

public class Test {
    /**
     * 学习lambda表达式简化匿名类代码
     */
    public static void main(String[] args) {
/*        Animal animal = new Animal() {
            @Override
            public void run() {
                System.out.println("跑得快");
            }
        };*/
        
        // lambda简化匿名类只能用在函数式接口的抽象类上
/*        Animal animal = ()->{
            System.out.println("跑得快");
        }*/
        // alt+enter 可以变成lambda格式
        Animal2 animal2 = () -> System.out.println("跑得快");
        
    }
    
}

@FunctionalInterface // 函数式接口校验注解
interface Animal2{
    void run();
}

集合

集合和数组都是容器
数组：长度固定，类型固定，数组可以存储基本类型和引用类型的数据，数组适合数据个数和类型确定的场景
集合：大小不固定，类型不固定，非常适合元素的增删操作，集合中只能存储引用类型数据，如果要存储基本类型数据可以选用包装类，适合数据的个数不确定，需要进行增删元素的时候

集合体系

集合都是支持泛型的，泛型的作用是可以在编译阶段约束集合只能操作某种数据类型

ArrayList<String> arrayList = new ArrayList<>();
集合中只能存储引用类型数据，如果要存储基本类型数据可以选用包装类

集合常用api

集合遍历方式

迭代器 iteration

        // iteration
        Iterator<String> iterator = collection.iterator();
        while (iterator.hasNext()) {
            String next = iterator.next();
            System.out.println(next);
        }

foreach

        // foreach
        for (String s : collection) {
            System.out.println(s);
        }

lambda表达式

        // lambda
        collection.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });

        collection.forEach((String s) -> {
                System.out.println(s);
            }
        );
        
        collection.forEach(s-> System.out.println(s));

        collection.forEach(System.out::println);

泛型

泛型类

泛型方法

类型强制转换

public class Test {
    // 泛型方法
    public static void main(String[] args) {
        String[] name = {"wnagt","tao","wwww"};
        printArray(name);

    }
    public static <T> void printArray(T[] t){
        StringBuilder sb = new StringBuilder("[");
        if (!Objects.isNull(t)){
            for (int i = 0 ; i<t.length;i++) {
                sb.append(t[i]).append(i==t.length-1?']':',');
            }
            System.out.println(sb);
        }
    }
}

泛型接口

public interface People <E>{
    void add(E e);
    void remove(E e);
}

public class School implements People<Student>{
    @Override
    public void add(Student student) {
        
    }

    @Override
    public void remove(Student student) {

    }
}

泛型通配符、上下限

使用泛型时

泛型的效果与Object类型，但是Object属于多态，不能使用子类独有的功能

标签：增强,04,void,System,泛型,println,javase,public,out
来源： https://www.cnblogs.com/WT404/p/16482494.html