java _list

一.引入泛型机制

<>

// 1. 尖括号 <> 是泛型的标志
// 2. E 是类型变量(Type Variable)，变量名一般要大写
// 3. E 在定义时是形参，代表的意思是 MyArrayList 最终传入的类型，但现在还不知道
public class MyArrayList<E> {
private E[] array;
private int size;
}

原理：

1. 泛型是作用在编译期间的一种机制，即运行期间没有泛型的概念。

2. 泛型代码在运行期间，就是我们上面提到的，利用 Object 达到的效果（这里不是很准确，以后会做说明）。

// 定义了一个元素是 Book 引用的 
MyArrayList MyArrayList books = new MyArrayList(); 
books.add(new Book()); // 会产生编译错误，Person 类型无法转换为 Book 类型 
books.add(new Person()); // 不需要做类型转换 
Book book = book.get(0); // 不需要做类型转换 
// 会产生编译错误，Book 类型无法转换为 Person 类型 
Person person = book.get(0); 

通过以上代码，我们可以看到泛型类的一个使用方式：只需要在所有类型后边跟尖括号，并且尖括号内是真正的类 型，即 E 可以看作的最后的类型。

注意： Book 只能想象成 E 的类型，但实际上 E 的类型还是 Object。

1. 泛型是为了解决某些容器、算法等代码的通用性而引入，并且能在编译期间做类型检查。

2. 泛型利用的是 Object 是所有类的祖先类，并且父类的引用可以指向子类对象的特定而工作。

3. 泛型是一种编译期间的机制，即 MyArrayList 和 MyArrayList 在运行期间是一个类型。

4. 泛型是 java 中的一种合法语法，标志就是尖括号 <>

二.包装类引入

装箱：将基本数据类型抓化成包装类

拆箱：将包装类转化为基本数据类型‘

自动装箱及自动拆箱

int i = 10;
Integer ii = i; // 自动装箱
Integer ij = (Integer)i; // 自动装箱
int j = ii; // 自动拆箱
int k = (int)ii; // 自动拆箱
 

还有显式拆箱及显式装箱 

public static void main2(String[] args) {

Integer a = Integer.valueOf(10);

int b = a.intValue();

double d = a.doubleValue();

System.out.println(b);

System.out.println(d);

}

 

Integer常考面试题：

 public static void main3(String[] args) {
        Integer a = 128;
        Integer b = 128;
        System.out.println(a == b);//false
    }
public static void main3(String[] args) {
        Integer a = 127;
        Integer b = 127;
        System.out.println(a == b);//true
    }

 

 

 三.List

 官方文档：

List (Java Platform SE 8 )

ArrayList (Java Platform SE 8 )

LinkedList (Java Platform SE 8 )

list：

 

Arraylist:

 

 linkedlist:

 

代码示例： 

import java.util.List;
import java.util.ArrayList;
import java.util.LinkedList;
public class ListDemo {
public static void main(String[] args) {
List<String> courses = new ArrayList<>();
courses.add("C 语言");
courses.add("Java SE");
 courses.add("Java Web");
courses.add("Java EE");
// 和数组一样，允许添加重复元素
courses.add("C 语言");
// 按照添加顺序打印
System.out.println(courses);
// 类似数组下标的方式访问
System.out.println(courses.get(0));
System.out.println(courses);
courses.set(0, "计算机基础");
System.out.println(courses);
List<String> subCourses = courses.subList(1, 3);// 截取部分 [1, 3)
System.out.println(subCourses);
List<String> courses2 = new ArrayList<>(courses);// 重新构造
System.out.println(courses2);
List<String> courses3 = new LinkedList<>(courses);
System.out.println(courses3);
// 引用的转换
ArrayList<String> courses4 = (ArrayList<String>)courses2;//强制转换类型必须与其new的类型相同
System.out.println(courses4);
// LinkedList<String> c = (LinkedList<String>)course2; 错误的类型
LinkedList<String> courses5 = (LinkedList<String>)courses3;
System.out.println(courses5);
// ArrayList<String> c = (ArrayList<String>)course3; 错误的类型
}
}
运行结果
[C 语言, Java SE, Java Web, Java EE, C 语言]
C 语言
[C 语言, Java SE, Java Web, Java EE, C 语言]
[计算机基础, Java SE, Java Web, Java EE, C 语言]
[Java SE, Java Web]
[计算机基础, Java SE, Java Web, Java EE, C 语言]
[计算机基础, Java SE, Java Web, Java EE, C 语言]
[计算机基础, Java SE, Java Web, Java EE, C 语言]
[计算机基础, Java SE, Java Web, Java EE, C 语言]

  练习：

 

class Student {
    private String name;
    private String classes;
    private double score;

    public Student(String name, String classes, double score) {
        this.name = name;
        this.classes = classes;
        this.score = score;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getClasses() {
        return classes;
    }

    public void setClasses(String classes) {
        this.classes = classes;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", classes='" + classes + '\'' +
                ", score=" + score +
                '}';
    }
}
 public static void main6(String[] args) {
        ArrayList<Student> list2 = new ArrayList<>();
        list2.add(new Student("bit","1",99.9));
        list2.add(new Student("gb","2",19.9));
        System.out.println(list2);
        System.out.println("===============");
        for (Student s  : list2) {
            System.out.println(s);
        }

 

public static void func(String str1,String str2) {
        if(str1 == null || str2 == null) {
            return;
        }
        List<Character> ret = new ArrayList<>();
        for (int i = 0; i < str1.length(); i++) {
            char ch = str1.charAt(i);
            if(!str2.contains(ch+"")) {
                ret.add(ch);
            }
        }
        //System.out.println(ret);
        for (char ch :ret) {
            System.out.print(ch);
        }
    }

    public static void main8(String[] args) {
        func("come","come");
    }

 

 

public static void main7(String[] args) {
        ArrayList<Integer> list2 = new ArrayList<>();
        list2.add(10);
        list2.add(2);
        list2.add(9);
        Collections.sort(list2);
        System.out.println(list2);
    }

 

力扣