【Java】List

目录

🥬初识泛型

🥬包装类

💧装箱与拆箱

🥬List的使用

💧练习

🥬小结

🥬初识泛型

什么是泛型？

泛型本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

为什么要使用泛型？

我们之前所了解的顺序表，里面只能放int类型的数据，但是如果我们要存放其他数据类型的数据，该怎么办呢？

class MyArrayList{                   
    private Object[] elem;           
    private int useSize;             
                                     
    public MyArrayList() {           
        this.elem =new Object[10];   
    }                                
    public void add(Object val){     
        this.elem[useSize]=val;      
        useSize++;                   
    }                                
    public Object get(int pos){      
        return this.elem[pos];       
    }                                
}
 public class Test {                                               
    public static void main(String[] args) {                      
        MyArrayList myArrayList=new MyArrayList();                
        myArrayList.add("abc");                                   
        myArrayList.add("1");                                     
        String ret=(String) myArrayList.get(0);                   
        System.out.println(ret);                                  
    }                                                                                                 

 public static void main(String[] args) {
        MyArrayList<String> myArrayList=new MyArrayList<>();
        myArrayList.add("A");
        myArrayList.add("B");
        String ret= myArrayList.getpos(1);
        System.out.println(ret);
        System.out.println("==================");
        MyArrayList<Integer> myArrayList1=new MyArrayList<>();
        myArrayList1.add(12);
        myArrayList1.add(34);
        int ret1=myArrayList1.getpos(0);
        System.out.println(ret1);
 
    }
//1. 尖括号 <> 是泛型的标志
//2. E 是类型变量(Type Variable)，变量名一般要大写
//3. E 在定义时是形参，代表的意思是 MyArrayList 最终传入的类型，但现在还不知道 
    class MyArrayList<E> {
    private E[] elm;
    private int useSize;
    public MyArrayList(){
        this.elm=(E[]) new Object[10];
    }
    public void add(E val){
        this.elm[useSize]=val;
        useSize++;
    }
    public E getpos(int pos){
        return this.elm[pos];
    }
}

 总结：

泛型的意义:
1、自动对类型进行检查。
2、自动对类型进行强制类型的转换。

🥬包装类

💧装箱与拆箱

    public static void main(String[] args) {
        //1.
        Integer a=12;//装箱(隐式)
        int b=a;//拆箱
        //2.
        Integer integer=new Integer(12);//装箱(显示)
        int c=integer;//拆箱
        //3.
        Integer a1=Integer.valueOf(12);//装箱（显示）
        int b1=a1.intValue();//拆箱
        double b2=a1.doubleValue();
        byte b3=a1.byteValue();
        float b4=a1.floatValue();
        long b5=a1.longValue();
        short b6= a1.shortValue();
    }

 但是要注意一点：

新建一个Integer类型对象，它的取值范围是-128--127，如果放入a的值超过这个范围，则会新建另一个对象放a。

   //1、   
  Integer a=127;
  Integer b=127;
  System.out.println(a==b);//true
  //2、
  Integer a=128;
  Integer b=128;
  System.out.println(a==b);//false
  //3、
  Integer a=-128;
  Integer b=-128;
  System.out.println(a==b);//true
  //4、
  Integer a=-129;
  Integer b=-129;
  System.out.println(a==b);//false
 

🥬List的使用

List（线性表）常见方法的使用

我们找到List源码，可以知道List接口继承了Collection接口，所以List可以实现Collection接口的方法。

ArrayList（顺序表）：

 LinkedList（链表）：

LinkedList（）  无参构造

ArrayList打印四种方式：

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("hello");
        list.add("world");
        list.add("heihei");
        //1、
        System.out.println(list);
        //2、for循环
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i)+" ");
        }
        System.out.println();
        //3、for-each
        for (String s:list) {
            System.out.print(s+" ");
        }
        System.out.println();
        //4、迭代器打印
        Iterator<String> it=list.iterator();
        while(it.hasNext()){
            System.out.print(it.next()+" ");
        }
 
         System.out.println();
        System.out.println("========迭代器List相关打印==========");
        ListIterator<String> it2 = list.listIterator();
        while (it2.hasNext()) {
            String ret = it2.next();
            if (ret.equals("hello")) {
               it2.remove();//首先需要使用next方法迭代出集合中的元素 ，然后才能调用remove方法
            } else {
                System.out.print(ret + " ");
            }
        }
    }

💧练习

扑克牌：

class Card{
    private int rank;//数字
    private String suit;//花色
 
    public Card(int rank, String suit) {
        this.rank = rank;
        this.suit = suit;
    }
 
    public int getRank() {
        return rank;
    }
 
    public void setRank(int rank) {
        this.rank = rank;
    }
 
    public String getSuit() {
        return suit;
    }
 
    public void setSuit(String suit) {
        this.suit = suit;
    }
 
    @Override
    public String toString() {
        return rank +":"+ suit + " ";
    }
}
 
public class TestDemo4 {
    public static void main1(String[] args) {
        List<Card> cards=buyCard();
        System.out.println("买牌"+cards);
        shuffle(cards);
        System.out.println("洗牌"+cards);
        System.out.println("揭牌：三个人轮流揭五张牌");
        ArrayList<ArrayList<Card>> hand=new ArrayList<>();//相当于一个二维数组
        ArrayList<Card> hand1=new ArrayList<>();
        ArrayList<Card> hand2=new ArrayList<>();
        ArrayList<Card> hand3=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("hand1"+hand1);
        System.out.println("hand2"+hand2);
        System.out.println("hand3"+hand3);
        System.out.println("剩余的牌"+cards);
    }
//洗牌
    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 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 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++) {
                cards.add(new Card(j,suits[i]));
            }
        }
        return cards;
    }
}

杨辉三角：

  public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int sc= scanner.nextInt();
        List<List<Integer>> ret= generate(sc);
        for (int i = 0; i < ret.size(); i++) {
            System.out.println(ret.get(i));
        }
    }
    public static List<List<Integer>> generate(int numRows) {
        List<List<Integer>> ret=new ArrayList<>();
        List<Integer> list1=new ArrayList<>();
        list1.add(1);
        ret.add(list1);//把第一行的数据放到ret中
        for (int i = 1; i <numRows ; i++) {
            ArrayList<Integer> list=new ArrayList<>();
            list.add(1);
            List<Integer> prerow=ret.get(i-1);//获取上一行
            for(int j=1;j<i;j++){
                //中间
                int nums=prerow.get(j)+prerow.get(j-1);
                list.add(nums);
            }
            list.add(1);//每一行的结尾
            ret.add(list);
        }
        return ret;
    }

🥬小结

以上就是今天的内容了，有什么问题都可以在评论区留言哦✌✌✌！