【Java】List
目录
?初识泛型
什么是泛型？
泛型本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。
为什么要使用泛型？
我们之前所了解的顺序表，里面只能放int类型的数据，但是如果我们要存放其他数据类型的数据，该怎么办呢？
我们在了解多态过程中已知一个前提，基类的引用可以指向子类的对象。
其次，我们也已知
Object
是
java
中所有类的祖先类。
其次，我们也已知
Object
是
java
中所有类的祖先类。
那么，要解决上述问题，我们很自然的想到一个解决办法，将我们的顺序表的元素类型定义成
Object 类型，这
样我们的
Object
类型的引用可以指向
其他类型的对象。
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
是所有类的祖先类，并且父类的引用可以指向子类对象的特定而工作。
泛型利用的是
Object
是所有类的祖先类，并且父类的引用可以指向子类对象的特定而工作。
3.
泛型是一种编译期间的机制，即
MyArrayList<String>
和
MyArrayList<Integer>
在运行期间是一个类型。
泛型是一种编译期间的机制，即
MyArrayList<String>
和
MyArrayList<Integer>
在运行期间是一个类型。
4.
泛型是
java
中的一种合法语法，标志就是尖括号
<> 。
泛型是
java
中的一种合法语法，标志就是尖括号
<> 。
泛型的意义:
1、自动对类型进行检查。
2、自动对类型进行强制类型的转换。
?包装类
Object
引用可以指向任意类型的对象，但有例外出现了，8
种基本数据类型不是对象，那岂不是刚才的泛型机制要
失效了？
引用可以指向任意类型的对象，但有例外出现了，8
种基本数据类型不是对象，那岂不是刚才的泛型机制要
失效了？
实际上也确实如此，为了解决这个问题，
java
引入了一类特殊的类，即这
8
种基本数据类型的包装类，在使用过程中，会将类似
int
这样的值包装到一个对象中去。
java
引入了一类特殊的类，即这
8
种基本数据类型的包装类，在使用过程中，会将类似
int
这样的值包装到一个对象中去。
基本就是类型的首字母大写，除了
Integer
和
Character
。
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
二维码