JAVA之泛型类与List的使用

泛型

1. 泛型类的诞生：增加编译期间的类型检查，取消类型转换的应用

2. 泛型类的分类：
   1） 泛型类：尖括号<>是泛型的标志
   2） E是类型变量（Type variable）变量名一般要大写
   3） E在定义时是形参，代表的意思是MyArrayList最终传入的类型，但现在还不知道
   注意：泛型类可以一次有多个类型变量，用逗号分割

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

4. 泛型类的使用
   //定义了一个元素是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

5. 泛型总结
   1） 泛型是为了解决某些容器，算法等代码的通用性而引入，并且能在编译期间做类型检查
   2） 泛型利用的是Object是所有类的祖先类，并且父类的引用可以指向子类对象的特定而工作
   3） 泛型是一种编译期间的机制，即MyArrayList和MyArrayList在运行期间是一个类型
   4） 泛型是Java中的一种合法语法，标志就是尖括号<>

6. 自动装箱和自动拆箱是工作在编译期间的一种机制
   List的使用

7. 常见方法：List（线性表）
   boolean add(E,e):尾插e
   E remove(int index):删除index位置元素
   Void clear(():清空
   Arraylist(顺序表)： ArrayLIst（） 无参构造
   ArrayList(Collection<? Extends E>c) 利用其他Collection构建ArrayList
   LinkedList(链表）：LinkedList() 无参构造
   List的使用：代码练习
   public class Card {
   public int rank; //牌面值
   public String suit; //花色；
   @Override
   public String toString(){
   return String.format("[%s %d]",suit,rank);
   }
   }
   import java.util.List;
   import java.util.ArrayList;
   import java.util.Random;
   public class CardGame {
   public static final String[] SUITS = {“♠”, “♥”, “♣”, “♦”};
   //买一副牌
   private static List buyDeck() {
   List deck = new ArrayList<>(52);
   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();
   card.rank = rank;
   card.suit = suit;
   deck.add(card);
   }
   }
   return deck;
   }
   private static void swap(List deck, int i, int j) {
   Card t = deck.get(i);
   deck.set(i, deck.get(j));
   deck.set(j, t);
   }

   private static void shuffle(List deck) {
   Random random = new Random(20190910);
   for (int i = deck.size() - 1; i > 0; i–) {
   int r = random.nextInt(i);
   swap(deck, i, r);
   }
   }
   public static void main(String[] args) {
   List deck = buyDeck();
   System.out.println(“刚买回来的牌”);
   System.out.println(deck);
   shuffle(deck);
   System.out.println(“洗过的牌”);
   System.out.println(deck);
   List<List> hands = new ArrayList<>();
   hands.add(new ArrayList<>());
   hands.add(new ArrayList<>());
   hands.add(new ArrayList<>());
   for (int i = 0; i < 5; i++) {
   for (int j = 0; j < 3; j++) {
   hands.get(j).add(deck.remove(0));
   }
   }
   for (int i = 0; i < 5; i++) {
   for (int j = 0; j < 3; j++) {
   hands.get(j).add(deck.remove(0));
   }
   }
   System.out.println(“剩余的牌：”);
   System.out.println(deck);
   System.out.println(“A手中的牌：”);
   System.out.println(hands.get(0));
   System.out.println(“B手中的牌：”);
   System.out.println(hands.get(1));
   System.out.println(“C手中的牌：”);
   System.out.println(hands.get(2));
   }
   }
   运行结果：

标签：JAVA,deck,int,List,System,泛型,之泛,println,out
来源： https://blog.csdn.net/qq_44929652/article/details/100744719