List基本使用

目录

1.泛型

1.1 泛型类的定义

1.2 泛型背后作用时期和背后的简单原理

1.3 泛型类的使用

1.4 泛型总结

2.包装类(Wrapper Class)

2.1 基本数据类型和包装类直接的对应关系

2.2 包装类的使用，装箱(boxing)和拆箱(unboxing)

2.3 自动装箱(autoboxing)和自动拆箱(autounboxing)

3. List 的使用

 3.1 常见方法

3.2 代码示例

 3.3 综合练习

---

1.泛型

1.1 泛型类的定义

. 尖括号 <> 是泛型的标志

2.E 是类型变量 (TypeVariable) ，变量名一般要大写

3.E 在定义时是形参，代表的意思是 MyArrayList 最终传入的类型，但现在还不知道。

public class MyArrayList<E> {
    private E[] array;
    private int size;
    //.....
}

注意：泛型类可以一次有多个类型变量，用逗号分割。

1.2 泛型背后作用时期和背后的简单原理

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

2. 泛型代码在运行期间，利用 Object 达到的效果。

1.3 泛型类的使用

//定义了一个元素是Book引用的MyArrayList
MyArrayList<Book> books = new MyArrayList<Book>();
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.4 泛型总结

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

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

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

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

2.包装类(Wrapper Class)

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

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

2.1 基本数据类型和包装类直接的对应关系

基本数据类型	包装类
byte	Byte
short	Short
int	Integet
long	Long
float	Float
double	Double
char	CHaracter
boolean	Boolean

基本就是类型的首字母大写，除了 Integer 和 Character 。

2.2 包装类的使用，装箱(boxing)和拆箱(unboxing)

int i = 10; 

// 装箱操作，新建一个 Integer 类型对象，将 i 的值放入对象的某个属性中 
Integer ii = Integer.valueOf(i); 
Integer ij = new Integer(i); 

// 拆箱操作，将 Integer 对象中的值取出，放到一个基本数据类型中 
int j = ii.intValue();

2.3 自动装箱(autoboxing)和自动拆箱(autounboxing)

可以看到在使用过程中，装箱和拆箱带来不少的代码量，所以为了减少开发者的负担，java 提供了自动机制。

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

注意： 自动装箱和自动拆箱是工作在编译期间的一种机制。

3. List 的使用

 3.1 常见方法

（1）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)	E get (int 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

（2）ArrayList （顺序表） ：

方法	解释
ArrayList ()	无参数构造
ArrayList(Collection<? extends E> c)	利用其他 Collection 构建 ArrayList
ArrayList(int intialCapacity)	指定顺序表初始容量

LinkeList (链表)

方法	解释
LinkeList ( )	无参数构造

3.2 代码示例

尾插、获取下标 i 的元素

import java.util.ArrayList;
import java.util.List;

public class ListTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        //尾插
        list.add("we");
        list.add("are");
        list.add("java");
        list.add("student");
        System.out.println("尾插： "+ list);//以字符串打印

        //遍历打印,获取下标 i 的元素
        System.out.print("获取下标 i 的元素 :");
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i)+" ");
        }
    }
}

 修改下标 i 的值，截取部分字符串

import java.util.ArrayList;
import java.util.List;

public class ListTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        //尾插
        list.add("we");
        list.add("are");
        list.add("java");
        list.add("student");

        //将下标 i 位置元素设置为 element
        list.set(1,"element");
        System.out.println(list);
        // 截取部分 [1, 3),遵循闭右开原则
        List<String> list1 = list.subList(1,3);
        System.out.println(list1);

    }
}

 重新构造、引用转换

public class ListTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        //尾插
        list.add("we");
        list.add("are");
        list.add("java");
        list.add("student");

       //重新构造
        List<String> list3 = new ArrayList<>(list);
        System.out.println(list3);

        //引用转换
        ArrayList<String> arrayList = new ArrayList<>(list);
        System.out.println(arrayList);

        ArrayList<String> arrayList1 =( ArrayList<String>)(list);
        System.out.println(arrayList1);
    }
}

 3.3 综合练习

扑克牌

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.Callable;

class Card {
    private int rank;//数字
    private String suit;

    public Card(int rank, String suit) {
        this.rank = rank;
        this.suit = suit;
    }

    @Override
    public String toString() {
        return "["+this.suit+":"+this.rank+"]";
    }
}

public class CardTest {
    private static final String[] suits = {"♥","♠","♣","♦"};
    //买牌
    public static List<Card> buyCard() {
        ArrayList<Card> cards = new ArrayList<>();
        for (int i = 0; i < 4; i++) {
            for (int j = 1; j <= 13; j++) {
                /*String suit = suits[i];
                int rank = j;
                Card card = new Card(rank,suit);
                cards.add(card);*/
                cards.add(new Card(j,suits[i]));
            }
        }
        return cards;
    }

    //洗牌
    private static void swap(List<Card> cards,int i,int j){
        Card tmp = cards.get(i);
        cards.set(i,cards.get(j));
        cards.set(j,tmp);
    }


   public static void shuffle(List<Card> cards) {
        int size = cards.size();
        for (int i = size-1; i > 0; i--) {
            Random random = new Random();
            int rand = random.nextInt(i);
            swap(cards,i,rand);
        }
    }

    public static void main(String[] args) {
        List<Card> cards = buyCard();
        System.out.println("买牌： "+ cards );
        shuffle(cards);
        System.out.println("洗牌："+cards);
        System.out.println("揭牌：3个人每个人轮流揭5张牌");

        ArrayList<List<Card>> hand = new ArrayList<>();

        List<Card> hand2 = new ArrayList<>();
        List<Card> hand3 = new ArrayList<>();
        List<Card> hand1 = new ArrayList<>();

        hand.add(hand1);
        hand.add(hand2);
        hand.add(hand3);
        //每个人，轮流揭牌
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 3; j++) {
                Card card = cards.remove(0);
                hand.get(j).add(card);
            }
        }
        System.out.println("第1个人的牌："+hand1);
        System.out.println("第2个人的牌："+hand2);
        System.out.println("第3个人的牌："+hand3);
        System.out.println("剩下的牌："+cards);
    }
}