java 接收实体List java接口接收list参数

转载

人类新新 2024-05-05 15:56:25

文章标签 java 接收实体List java System 泛型顺序表 文章分类 Java 后端开发

文章目录

1. 预备知识-泛型(Generic)

1.1 泛型的引入
1.2 泛型的分类
1.3 泛型类的定义的简单演示
1.4 泛型背后作用时期和背后的简单原理
1.5 泛型类的使用
1.6 泛型总结

2. 预备知识-包装类(Wrapper Class)

2.1 基本数据类型和包装类直接的对应关系
2.2 包装类的使用，装箱(boxing)和拆箱(unboxing)
2.3 自动装箱(autoboxing)和自动拆箱(autounboxing)
2.4 javap 反编译工具

3. List 的使用

3.1 常见方法
3.2 示例

4. ArrayList与顺序表

4.1 ArrayList简介

5. ArrayList使用

5.1 ArrayList的构造
5.2 ArrayList常见操作
5.3 ArrayList的遍历
5.4 ArrayList的扩容机制

6 扑克牌

1. 预备知识-泛型(Generic)

1.1 泛型的引入

问题：顺序表只能保存 int 类型的元素，如果现在需要保存指向 Person 类型对象的引用的顺序表，请问应该如何解决？如果又需要保存指向 Book 对象类型的引用呢？回答：

首先，我们在学习多态过程中已知一个前提，基类的引用可以指向子类的对象。
其次，我们也已知 Object 是 java 中所有类的祖先类。那么，要解决上述问题，我们很自然的想到一个解决办法，将我们的顺序表的元素类型定义成 Object 类型，这样我们的 Object 类型的引用可以指向 Person 类型的对象或者指向 Book 类型的对象了。示例代码：

public class MyArrayList {
private Object[] array; // 保存顺序表的元素，即 Object 类型的引用
private int size; // 保存顺序表内数据个数
public void add(Object o) { 尾插 }
public Object get(int index) { 获取 index 位置的元素 }
...
}

我们可以就可以很自由的存储指向任意类型对象的引用到我们的顺序表了。示例代码：

MyArrayList books = new MyArrayList();
for (int i = 0; i < 10; i++) {
books.add(new Book()); // 尾插 10 本书到顺序表
}
MyArrayList people = new MyArrayList();
for (int i = 0; i < 10; i++) {
people.add(new Person()); // 尾插 10 个人到顺序表
}

现在的 MyArrayList 虽然可以做到添加任意类型的引用到其中了，但遇到以下代码就会产生问题。

MyArrayList books = new MyArrayList();
books.add(new Book);
// 将 Object 类型转换为 Person 类型，需要类型转换才能成功
// 这里编译正确，但运行时会抛出异常 ClassCastException
Person person = (Person)books.get(0);

所以我们需要一种机制，可以 1. 增加编译期间的类型检查 2. 取消类型转换的使用泛型就此诞生！

1.2 泛型的分类

泛型类
泛型方法

1.3 泛型类的定义的简单演示

// 1. 尖括号 <> 是泛型的标志
// 2. E 是类型变量(Type Variable)，变量名一般要大写
// 3. E 在定义时是形参，代表的意思是 MyArrayList 最终传入的类型，但现在还不知道
public class MyArrayList<E> {
 private E[] array;
 private int size;
 
 ...
}

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

public class TestDemo {

    public static void main(String[] args) {
        TreeMap<String,String> map2 = new TreeMap<>();
        map2.put("及时雨","宋江");
        map2.put("国民女神","高圆圆");
        System.out.println(map2);

        HashMap<String,String> map = new HashMap<>();
        map.put("及时雨","宋江");
        map.put("国民女神","高圆圆");
        System.out.println(map);
    }

    public static void main4(String[] args) {
        Map<String,String> map = new HashMap<>();
        map.put("及时雨","宋江");
        map.put("国民女神","高圆圆");
        System.out.println(map);
        System.out.println("====================");

        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        for( Map.Entry<String, String> entry : entrySet) {
            System.out.println("key: "+entry.getKey()+" value:"+entry.getValue());
        }

    }
    public static void main3(String[] args) {

        Map<String,String> map = new HashMap<>();
        map.put("国民女神","高圆圆");
        map.put("及时雨","宋江");

        String ret = map.getOrDefault("及时雨","博哥");
        System.out.println(ret);
        boolean flg = map.containsKey("国民女神2");
        System.out.println(flg);

        Map<String,String> map2 = new TreeMap<>();

    }
    public static void main2(String[] args) {
        Collection<String> collection = new ArrayList<>();
        collection.add("hello");
        collection.add("hello2");
        //System.out.println(collection);
        Object[] objects = collection.toArray();
        System.out.println(Arrays.toString(objects));
        /*collection.clear();
        System.out.println("===================");
        System.out.println(collection);
        System.out.println(collection.isEmpty());*/
    }

    public static void main1(String[] args) {
        Collection<String> collection = new ArrayList<>();
        collection.add("hello");
        collection.add("hello2");
        //collection.add(1);
        //尖括号当中 放的类型 一定要是 类类型 不能是简单的基本类型
        Collection<Integer> collection2 = new ArrayList<>();
        collection2.add(1);
        collection2.add(2);
        collection2.add(13);

    }
}

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

class MyArrayList<E> {
    private E[] elem;
    private int usedSize;
    public MyArrayList() {
        this.elem = (E[])new Object[10];
        //this.elem = new E[10];
    }
    public void add(E val) {
        this.elem[usedSize] = val;
        usedSize++;
    }
    public E get(int pos) {
        return this.elem[pos];
    }

    /*public <T> T[] getArray(int size) {
        T[] genericArray = new T[size]; // suppose this is allowed
        return genericArray;
    }*/

    public Object[] getArray(int size) {
        Object[] genericArray = new Object[size];
        return genericArray;
    }

}
public class TestDemo2 {

    public static void main(String[] args) {
        MyArrayList<String> myArrayList1 = new MyArrayList<>();
        //String[] rets = (String[])myArrayList1.getArray(10);
    }

    public static void main4(String[] args) {
        MyArrayList<String> myArrayList1 = new MyArrayList<>();
        System.out.println(myArrayList1);
        MyArrayList<Integer> myArrayList2 = new MyArrayList<>();
        System.out.println(myArrayList2);
        MyArrayList<Boolean> myArrayList3 = new MyArrayList<>();
        System.out.println(myArrayList3);

    }

    public static void main3(String[] args) {
        MyArrayList<String> myArrayList1 = new MyArrayList<>();
        myArrayList1.add("ABC");
        myArrayList1.add("bit");
        String ret = myArrayList1.get(1);
        System.out.println(ret);

        MyArrayList<Integer> myArrayList2 = new MyArrayList<>();
        myArrayList2.add(1);
        myArrayList2.add(12);
        myArrayList2.add(31);
        int ret2 = myArrayList2.get(1);
        System.out.println(ret2);
    }

    public static void main2(String[] args) {
        MyArrayList<String> myArrayList1 = new MyArrayList<>();
        MyArrayList<Integer> myArrayList2 = new MyArrayList<>();
        MyArrayList<Boolean> myArrayList3 = new MyArrayList<>();
    }


    public static void main1(String[] args) {
        MyArrayList myArrayList = new MyArrayList();
        myArrayList.add(1);
        myArrayList.add("hello");
        String ret = (String)myArrayList.get(1);
        System.out.println(ret);
    }
}

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

1.5 泛型类的使用

// 定义了一个元素是 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.6 泛型总结

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

2. 预备知识-包装类(Wrapper Class)

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

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

基本数据类型	包装类
byte	Byte
short	Short
int	Integer
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)

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

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

public class TestDemo {
    public static void main(String[] args) {
        Integer a = 128;
        Integer b = 128;
        System.out.println(a == b);
    }

    public static void main3(String[] args) {
        Integer a = 123;//装箱  装包【隐式的】
        int b = a;//拆箱  拆包【隐式的】
        System.out.println(a+" " + b);        System.out.println("=============");

        Integer a2 = Integer.valueOf(123);//显示的装包
        Integer a3 = new Integer(123);//显示的装包
        int b2 = a2.intValue();//显示的拆包
        double d = a2.doubleValue();//显示的拆包
        int i = 10;//显示的初始化
    }
    public static void main2(String[] args) {
        String str = "123";
        int ret = Integer.valueOf(str);
        System.out.println(ret+1);
    }
    public static void main1(String[] args) {
        String[] strings = new String[10];
        Object o1 = new String[10];
        Object[] o2 = new String[10];
    }
}

2.4 javap 反编译工具

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

3. List 的使用

java 接收实体List java接口接收list参数_顺序表

List的官方文档ArrayList的官方文档

LinkedList的官方文档

3.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)	获取下标 index 位置元素
E set(int index, E element)	将下标 index 位置元素设置为 element
void clear()	清空
boolean contains(Object o)	判断 o 是否在线性表中
int indexOfindexOf(Object o)	返回第一个 o 所在下标
int lastIndexOf(Object o)	返回最后一个 o 的下标
List subList(int fromIndex, int toIndex)	截取部分 list

ArrayList（顺序表）：

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

LinkedList（链表）：

方法	解释
LinkedList()	无参构造

3.2 示例

import java.util.List;
import java.util.ArrayList;
import java.util.LinkedList;
public class ListDemo {
    public static void main(String[] args) {
        List<String> courses = new ArrayList<>();
        courses.add("C 语言");
        courses.add("Java SE");
  courses.add("Java Web");
        courses.add("Java EE");
        // 和数组一样，允许添加重复元素
        courses.add("C 语言");
        // 按照添加顺序打印
        System.out.println(courses);
        // 类似数组下标的方式访问
        System.out.println(courses.get(0));
        
        System.out.println(courses);
        courses.set(0, "计算机基础");
        System.out.println(courses);
        // 截取部分 [1, 3)
        List<String> subCourses = courses.subList(1, 3);
        System.out.println(subCourses);
        // 重新构造
        List<String> courses2 = new ArrayList<>(courses);
        System.out.println(courses2);
        List<String> courses3 = new LinkedList<>(courses);
        System.out.println(courses3);
        // 引用的转换
        ArrayList<String> courses4 = (ArrayList<String>)courses2;
        System.out.println(courses4);
        // LinkedList<String> c = (LinkedList<String>)course2; 错误的类型
        LinkedList<String> courses5 = (LinkedList<String>)courses3;
        System.out.println(courses5);
        // ArrayList<String> c = (ArrayList<String>)course3; 错误的类型
   }
}

运行结果 [C 语言, Java SE, Java Web, Java EE, C 语言] C 语言 [C 语言, Java SE, Java Web, Java EE, C 语言] [计算机基础, Java SE, Java Web, Java EE, C 语言] [Java SE, Java Web] [计算机基础, Java SE, Java Web, Java EE, C 语言] [计算机基础, Java SE, Java Web, Java EE, C 语言] [计算机基础, Java SE, Java Web, Java EE, C 语言] [计算机基础, Java SE, Java Web, Java EE, C 语言]

4. ArrayList与顺序表

4.1 ArrayList简介

在集合框架中，ArrayList是一个普通的类，实现了List接口，具体框架图如下：

java 接收实体List java接口接收list参数_System_02

【说明】

ArrayList实现了RandomAccess接口，表明ArrayList支持随机访问。
ArrayList实现了Cloneable接口，表明ArrayList是可以clone的。
ArrayList实现了Serializable接口，表明ArrayList是支持序列化的。
和Vector不同，ArrayList不是线程安全的，在单线程下可以使用，在多线程中可以选择Vector或者CopyOnWriteArrayList。
ArrayList底层是一段连续的空间，并且可以动态扩容，是一个动态类型的顺序表。

5. ArrayList使用

5.1 ArrayList的构造

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

public static void main(String[] args) {
    // ArrayList创建，推荐写法
    // 构造一个空的列表
    List<Integer> list1 = new ArrayList<>();
    
    // 构造一个具有10个容量的列表
    List<Integer> list2 = new ArrayList<>(10);
    list2.add(1);
    list2.add(2);
    list2.add(3);
    // list2.add("hello"); // 编译失败，List<Integer>已经限定了，list2中只能存储整形元素
    
    // list3构造好之后，与list中的元素一致
    ArrayList<Integer> list3 = new ArrayList<>(list2);
    
    // 避免省略类型，否则：任意类型的元素都可以存放，使用时将是一场灾难
    List list4 = new ArrayList();
    list4.add("111");
    list4.add(100);
}

5.2 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 indexOfindexOf(Object o)	返回第一个 o 所在下标
int lastIndexOf(Object o)	返回最后一个 o 的下标
List subList(int fromIndex, int toIndex)	截取部分 list

public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    list.add("JavaSE");
    list.add("JavaWeb");
    list.add("JavaEE");
    list.add("JVM");
    list.add("测试课程");
    System.out.println(list);
    
    // 获取list中有效元素个数
    System.out.println(list.size());
    
    // 获取和设置index位置上的元素，注意index必须介于[0, size)间
    System.out.println(list.get(1));
    list.set(1, "JavaWEB");
    System.out.println(list.get(1));
    
    // 在list的index位置插入指定元素，index及后续的元素统一往后搬移一个位置
    list.add(1, "Java数据结构");
    System.out.println(list);
    // 删除指定元素，找到了就删除，该元素之后的元素统一往前搬移一个位置
    list.remove("JVM");
    System.out.println(list);
    // 删除list中index位置上的元素，注意index不要超过list中有效元素个数,否则会抛出下标越界异常
    list.remove(list.size()-1);
    System.out.println(list);
    
    // 检测list中是否包含指定元素，包含返回true，否则返回false
if(list.contains("测试课程")){
        list.add("测试课程");
   }
    
    // 查找指定元素第一次出现的位置：indexOf从前往后找，lastIndexOf从后往前找
    list.add("JavaSE");
    System.out.println(list.indexOf("JavaSE"));
    System.out.println(list.lastIndexOf("JavaSE"));
    
    // 使用list中[0, 4)之间的元素构成一个新的ArrayList返回
    List<String> ret = list.subList(0, 4);
    System.out.println(ret);
    
    list.clear();
    System.out.println(list.size());
}

5.3 ArrayList的遍历

ArrayList 可以使用三方方式遍历：for循环+下标、foreach、使用迭代器。

public static void main(String[] args) {
    List<Integer> list = new ArrayList<>();
    list.add(1);
    list.add(2);
    list.add(3);
    list.add(4);
    list.add(5);
    // 使用下标+for遍历
    for (int i = 0; i < list.size(); i++) {
        System.out.print(list.get(i) + " ");
   }
    System.out.println();
    // 借助foreach遍历
    for (Integer integer : list) {
        System.out.print(integer + " ");
   }
    System.out.println();
    Iterator<Integer> it = list.listIterator();
    while(it.hasNext()){
        System.out.print(it.next() + " ");
   }
    System.out.println();
}

5.4 ArrayList的扩容机制

public static void main(String[] args) {
    List<Integer> list = new ArrayList<>();
    for (int i = 0; i < 100; i++) {
        list.add(i);
   }
}

ArrayList是一个动态类型的顺序表，即：在插入元素的过程中会自动扩容：以下是ArrayList源码中扩容方式

Object[] elementData;   // 存放元素的空间
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};  // 默认空间
private static final int DEFAULT_CAPACITY = 10;  // 默认容量大小
public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}
private void ensureCapacityInternal(int minCapacity) {
 ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
   }
    return minCapacity;
}
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;
    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
private void grow(int minCapacity) {
    // 获取旧空间大小
    int oldCapacity = elementData.length;
    
    // 预计按照1.5倍方式扩容
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    
    // 如果用户需要扩容大小 超过 原空间1.5倍，按照用户所需大小扩容
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    
    // 如果需要扩容大小超过MAX_ARRAY_SIZE，重新计算容量大小
    if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
    
    // 调用copyOf扩容
    elementData = Arrays.copyOf(elementData, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
    // 如果minCapacity小于0，抛出OutOfMemoryError异常
    if (minCapacity < 0)
        throw new OutOfMemoryError();
    
    return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}

【总结】

检测是否真正需要扩容，如果是调用grow准备扩容
预估需要库容的大小 2.1初步预估按照1.5倍大小扩容 2.2如果用户所需大小超过预估1.5倍大小，则按照用户所需大小扩容 2.3真正扩容之前检测是否能扩容成功，防止太大导致扩容失败
使用copyOf进行扩容

6 扑克牌

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 CardDemo {
    public static final String[] SUITS = {"♠", "♥", "♣", "♦"};
    // 买一副牌
    private static List<Card> buyDeck() {
        List<Card> 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<Card> 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<Card> deck) {
        Random random = new Random(20190905);
        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<Card> deck = buyDeck();
        System.out.println("刚买回来的牌:");
        System.out.println(deck);
        shuffle(deck);
        System.out.println("洗过的牌:");
        System.out.println(deck);
        // 三个人，每个人轮流抓 5 张牌
        List<List<Card>> 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));
           }
       }
        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));
   }
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。