【Java】List


目录

🥬初识泛型

🥬包装类

💧装箱与拆箱

🥬List的使用

💧练习

🥬小结


🥬初识泛型

什么是泛型?

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

为什么要使用泛型?

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

我们在了解多态过程中已知一个前提,基类的引用可以指向子类的对象。
其次,我们也已知
Object

java
中所有祖先类
那么,要解决上述问题,我们很自然的想到一个解决办法,将我们的顺序表的元素类型定义成
Object 类型,这
样我们的
Object
类型的引用可以指向
其他类型的对象。

代码示例:
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);                                  
    }                                                                                                 

我们可以看到什么类型的数据都可以存放,且每次取出数据都需要强制类型转换。

 那么问题又来了,用Object,什么类型都能存放,那么能不能存放指定类型?并且每次取出元素不需要强制类型转换?这时候就用到了泛型。

代码示例:

 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];
    }
}

ArrayList<E>中的E称为类型参数变量(相当于一个占位符)。

ArrayList<String>中的String为实际类型参数。

class ArrayList<E>表示当前类是一个泛型类。

 总结:

1.
泛型是为了解决某些容器、算法等代码的通用性而引入,并且能在编译期间做类型检查。
2.
泛型利用的是
Object
是所有类的祖先类,并且父类的引用可以指向子类对象的特定而工作。
3.
泛型是一种编译期间的机制,即
MyArrayList<String>

MyArrayList<Integer>
在运行期间是一个类型。
4.
泛型是
java
中的一种合法语法,标志就是尖括号
<> 。

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

🥬包装类

Object
引用可以指向任意类型的对象,但有例外出现了,8
种基本数据类型不是对象,那岂不是刚才的泛型机制要
失效了?
实际上也确实如此,为了解决这个问题,
java
引入了一类特殊的类,即这
8
种基本数据类型的包装类,在使用过程中,会将类似
int
这样的值包装到一个对象中去。

基本就是类型的首字母大写,除了
Integer

Character

💧装箱与拆箱

装箱操作,新建一个 Integer 类型对象,将 a 的值放入对象的某个属性中 。
拆箱操作,将 Integer 对象中的值取出,放到一个基本数据类型中 。
(装箱拆箱也可叫装包拆包)
示例代码:

    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;
    }

🥬小结

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

本图文内容来源于网友网络收集整理提供,作为学习参考使用,版权属于原作者。
THE END
分享
二维码
< <上一篇
  

)">
下一篇>>