目录

包装类（Wrapped Class)

包装类的使用---装箱和拆箱

自动装箱和自动拆箱 

Integer的易错题

javap反编译工具

List接口的使用

方法 

 

ArrayList

使用

打印

区别

扩容机制

ArrayList练习

字符集合

杨辉三角

​编辑 

---

 

 

包装类（Wrapped Class)

Object 引用可以指向任意类型的对象，但有例外出现了， 8 种基本数据类型不是对象，那岂不是刚才的 泛型机制要 失效了？

实际上也确实如此，为了解决这个问题，java 引入了一类特殊的类，即这 8 种基本数据类型的包装类，在使用过程 中，会将类似 int 这样的值包装到一个对象中去。

 

包装类的使用---装箱和拆箱

int i = 10;

//显式

// 装箱操作，新建一个 Integer 类型对象，将 i 的值放入对象的某个属性中

Integer ii = Integer.valueOf(i);

Integer ij = new Integer(i);

 

// 拆箱操作，将 Integer 对象中的值取出，放到一个基本数据类型中

int j = ii.intValue();

 

自动装箱和自动拆箱 

int i=10;

 

nteger ii = i; // 自动装箱

Integer ij = (Integer)i; // 自动装箱

 

int j = ii; // 自动拆箱

int k = (int)ii; // 自动拆箱

Integer的易错题

Integer a=127;
Integer b=127;
Sysyem.out.print(a==b);

 答案：true

Integer a=128;
Integer b=128;
Sysyem.out.print(a==b);

 

javap反编译工具

javap-c(jdk 中一个反编译工具来查看下自动装箱和自动拆箱过程，并且看到这个过程是发生在编译期)

 

List接口的使用

方法 

序列化：把一个对象转变为字符串

方法 ：

boolean add(E e) 尾插 e

 

void add(int index, E element) 将 e 插入到 index 位置

 

boolean addAll(Collection<? extends E> c) 尾插 c 中的元素

 

E remove(int index) 删除 index 位置元素

 

boolean remove(Object o) 删除遇到的第一个 o

 

E get(int index) 获取下标 index 位置元素

 

E set(int index, E element) 将下标 index 位置元素设置为 element

 

void clear() 清空

 

boolean contains(Object o) 判断 o 是否在线性表中

 

int indexOf(Object o) 返回第一个 o 所在下标

 

int lastIndexOf(Object o) 返回最后一个 o 的下标

 

List<E> subList(int fromIndex, int toIndex) 截取部分 list

 

方法

ArrayList() 无参构造

 

ArrayList(Collection<? extends E> c) 利用其他 Collection 构建 ArrayList

 

ArrayList(int initialCapacity) 指定顺序表初始容量

 

 

ArrayList

使用

boolean add(E e) 尾插 e

 

void add(int index, E element) 将 e 插入到 index 位置

 

boolean addAll(Collection<? extends E> c) 尾插 c 中的元素

 

E remove(int index) 删除 index 位置元素

 

boolean remove(Object o) 删除遇到的第一个 o

 

E get(int index) 获取下标 index 位置元素

 

E set(int index, E element) 将下标 index 位置元素设置为 element

 

void clear() 清空

 

boolean contains(Object o) 判断 o 是否在线性表中

 

int indexOf(Object o) 返回第一个 o 所在下标

 

int lastIndexOf(Object o)

打印

五种方法

       List<Integer> list1=new ArrayList<>(10);
        List<String> list2=new ArrayList<>();
        ArrayList<String> list3=new ArrayList<>();
        list2.add("It");
        list2.add("was love ");
        list2.add("at first sight.");
        //关于打印
        System.out.println(list2);
 
        System.out.println("------------------");
 
        for (int i = 0; i < list2.size(); i++) {
            System.out.print(list2.get(i)+" ");
        }
        System.out.println();
        System.out.println("------------------");
 
        for(String s:list2){
            System.out.print(s+" ");
        }
 
        System.out.println("--使用迭代器打印--");
        Iterator<String> it=list2.iterator();
        while(it.hasNext()){//判断后面是否还有元素
            System.out.print(it.next()+" ");//
        }
 
        System.out.println("--迭代器List相关打印");
        ListIterator<String> it2=list2.listIterator();
        while(it2.hasNext()){
            System.out.print(it2.next()+" ");
        }
        /**
         * 使用迭代删除（Iterator.remove()),可能会因为没有it.next()抛出并发修改异常（,
         * 先迭代元素再删除，避免对同一个迭代器remove多次而异常
         * ArrayList不是线程安全的
         *  ***/

 

 

区别

List<String> list1=new ArrayList<>();
 
ArrayList<String> list2=new ArrayList<>();

list1的方法比list2少，因为list1由父类List调用，就只能调用List接口的方法。除非子类重写了父类的方法。

扩容机制

ArrayList是一个动态的扩容机制，在插入元素过程中会自动扩容。

List<Integer> list = new ArrayList<>();
for (int i = 0; i < 100; i++) {
list.add(i);
}
//既然没给初始值，就不会存在越界问题吗？

1. 检测是否需要扩容，如果是调用grow准备扩容；
2. 预估需要库容的大小

• 初步预估按照1.5倍进行扩容；
• 如果用户所需要的大小超过预估1.5倍左右，则按照用户所需大小进行扩容；
• 真正扩容之前检测是否能扩容成功，防止太大导致扩容失败；
• 使用copyOf进行扩容；

 如果ArrayList调用不带参数的构造方法，那麽顺序表的大小是0，第一次add的时候，整个顺序表才变成了10；当这个10放满了，以1.5倍扩容；

如果调用的是给定容量的构造方法，那麽顺序表的大小就是你给定的容量，放慢了就仍然以1.5倍进行扩容；

ArrayList练习

1. 学生对象放在List中，每个学生有一个姓名，班级，考试成绩属性（double)次考试结束后，每个学生都获得了一个考试成绩，遍历list集合，并把学生对象的属性打印出来；
2.有一个List中存放整形元素，要求使用Collections.sort对他们排序
 

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 class TestDemo {
    public static void main2(String[] args) {
        ArrayList<Integer> integers=new ArrayList<>();
        integers.add(33);
        integers.add(11);
        integers.add(22);
 
        Collections.sort(integers);//Collections是一个类进行升序
        System.out.println(integers);
 
 
    }
    public static void main1(String[] args) {
        //<>中可以放自定义类型
        ArrayList<Student> students=new ArrayList<>();
        students.add(new Student("小明","102",99));
        students.add(new Student("小美","102",99.7));
        System.out.println(students);
    }
}
 

sum:

 * Collection是接口，继承他的接口的主要是List接口，Set接口，Queue接口
 * Collections是类，提供了集合相关操作的静态方法类,eg:Collections.reverse(list).
 * ArrayList可以在<>中放自定义类型；
 * *

 

3.删除第一个字符串中出现的第二个字符串中的字符。使用ArrayList解决

eg:

String str1="welcome to";
 
String str2="come";
 
输出结果：wl t  

 public static void main(String[] args) {
        String str1 = "welcome to";
        String str2 = "come";
        ArrayList<Character> list = new ArrayList<>();
        for (int i = 0; i < str1.length(); i++) {
            char ch = str1.charAt(i);
            if(!str2.contains(ch+"")){
                list.add(ch);
            }
 
        }
        //这样直接打印list的话打印的数组类型,so
        for(char ch:list){
            System.out.print(ch);
        }
    }

sum:

String中的contains方法(返回boolean类型，源码重写了equal方法）：A.contains(B),判断A字符串中是否包含字符串B

public static void main(String[] args) {
        String str1="hello";
        String str2="eo";
        System.out.println(str1.contains(str2));
}
输出false

字符集合

public class TestDemo {
    //a-97,A-65
    public static String func1(String str){
        StringBuilder sb=new StringBuilder();
        int[] array=new int[124];
        for (int i = 0; i < str.length(); i++) {
            char ch=str.charAt(i);
            if(array[ch]==0){
                sb.append(ch);
                array[ch]=0;
            }
        }
        return sb.toString();
 
    }
    public static String func(String str){
        StringBuilder sb=new StringBuilder();
        for(int i = 0;i< str.length();i++){
            char ch = str.charAt(i);
            if(!sb.toString().contains(ch+"")){
                sb.append(ch);
            }
        }
       return sb.toString();
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while(scanner.hasNextLine()){
            String str=scanner.nextLine();
            String ret=func(str);
            System.out.println(ret);
        }
 
    }
}

杨辉三角

class Solution {
    public List<List<Integer>> generate(int numRows) {
        List<List<Integer>> ret=new ArrayList<>();
        //第一行
        List<Integer> list1=new ArrayList<>();
        list1.add(1);
        ret.add(list1);//把第一行数据放在List中
        for(int i=1;i<numRows;i++){
            List<Integer> list=new ArrayList<>();
            list.add(1);//每一行开始都是1
            List<Integer> preRow=ret.get(i-1);//上一行
            for(int j=1;j<i;j++){
                int num1=preRow.get(j)+preRow.get(j-1);
                list.add(num1);
            }
            list.add(1);
            ret.add(list);
 
        }
        return ret;
 
 
    }
}