目录
包装类的自动装箱(autoboxing)和自动拆箱(autounboxing)
前言
在提及List时,首先得了解泛型,上面是我对泛型的详细介绍,可以先去看看。
预备知识-包装类(Wrapper Class)
因为泛型擦除机制的原因,所有的泛型最后都被擦成了Object类型,而我们知道,object引用可以指向任意类型的对象,但我们我熟知的八种基本数据类型并不是对象,那难道说要 "失去"八种基本数据类型的泛型了吗?
实际上也确实如此,为了解决这个问题,Java引入了一种特殊的类,即这八种数据类型的包装类,在使用 过程中,会将类似 int 这样的值包装到一个对象中。
八种基本数据类型及其对应的包装类:
包装类的使用-装箱和拆箱
int i = 10;
//装箱操作,新建一个 Integer 类型对象,将 i 的值放入对象的某个属性中
//①
Integer ii = Integer.valueOf(i);
//②
Integer ij = new Integer(i);
//拆箱操作,将 Integer 对象中的值取出,放到一个基本数据类型中
int j = ii.intValue();
int jj = ij.intValue();
可以看到,在使用包装类时装箱和拆箱带来不少的代码量,所以为了减少开发者的负担,java 提供了自动机制。
包装类的自动装箱(autoboxing)和自动拆箱(autounboxing)
int i = 10;
Integer ii = i; // 自动装箱
Integer ij = (Integer)i;// 自动装箱
int j = ii; // 自动拆箱
int k = (int)ii; // 自动拆箱
List类的自动装箱拆箱
List<Integer>list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
int sum = 0;
for (int i:list) {
sum += i;
}
System.out.println(sum);
我们通过反编译方便观察:
自动装箱、拆箱的陷阱
自动装箱没有想象中的那么难,但也没有那么简单,看下面这段代码:
Integer a = 1;
Integer b = 2;
Integer c = 2;
Integer d = 128;
Integer e = 128;
Integer f = 129;
System.out.println(a==b);
System.out.println(b==c);
System.out.println(d==e);
System.out.println(e==f);
结果:
因为自动装箱使我们没有注意到装箱方法valueOf的范围,容易犯错。
我们可以看到valueOf如果给定的值再[-128,127]之间是直接返回一个缓存数组里的对象,如果超出这个范围则会重写new一个对象,而我们知道new对象,那么引用是会改变的,所以造成了结果不同。
List的使用
因为List是一个接口,还是不能直接new一个对象,因此我们借用底下的实现类来使用,继续使用ArrayList吧。
基本方法:
我们注意到ArrayList有三种构造方法,分别使用看看:
//无参构造
List<Integer>list1 = new ArrayList<>();
list1.add(1);
list1.add(2);
list1.add(3);
System.out.println(list1);
//初始容量构造
List<Integer>list2 = new ArrayList<>(20);
list2.add(1);
list2.add(2);
list2.add(3);
System.out.println(list2);
//其他集合构造
List<Integer>list3 = new ArrayList<>(list2);
System.out.println(list3);
第三种泛型集合的返回值如果不知道可以戳这:泛型上下边界符 。
ArrayList的五种遍历方式:
//五种遍历方式
List<Integer>list1 = new ArrayList<>();
list1.add(1);
list1.add(2);
list1.add(3);
//底层重写了toString方法实现了遍历
//①
System.out.println(list1);
//②
System.out.println("======for循环遍历============");
for (int i = 0; i < list1.size(); i++) {
System.out.print(list1.get(i)+" ");
}
System.out.println();
//③
System.out.println("========for-each循环遍历===========");
for (int i: list1) {
System.out.print(i + " ");
}
//④
System.out.println();
System.out.println("========迭代器打印=======");
Iterator<Integer>it = list1.iterator();
while(it.hasNext()){
System.out.print(it.next()+" ");
}
System.out.println();
System.out.println("========List迭代器打印=======");
ListIterator<Integer> it1 = list1.listIterator();
while(it1.hasNext()){
System.out.print(it1.next()+" ");
}
上面的方法就不一一演示了。
我们前面讲了ArrayList的三种构造方法,其中有一种是没有初始容量,另一种是有初始容量的,但问题是他们都能插入元素,这又得从源码角度分析:
如果ArrayList调用不带参数的构造方法,那么顺序表的大小是0,当第一次add的时候,整个顺序表才变为了10,而不是默认容量是10,当10放满了,开始1.5倍扩容。
iterator 和 Listiterator
两种迭代器接口的方法:可以逐一去试试,这里就不多说了,接口这么多,只需记住几个常用的就ok。
iterator 和 Listiterator两种接口有些方法我们可以使用,但要注意:
当我们在迭代的同时删除元素时,首先需要使用next方法迭代出集合中的元素 ,然后才能调用remove方法,否则集合可能会因为对同一个Iterator remove了多次而造成这个异常。
我们这样写后才不会报错,有点类似于java的scanner必须接收掉一行空格一样,不然会造成下一行输入变成空。
这样我们里面的东西删完了,第二次迭代器打印就为空。
add方法:
发现它插入的位置是it移动的下一位。
简单模拟ArrayList
模拟集中ArrayList里的方法
import java.util.Arrays;
public class MyArrayList<E> {
private E[]element;
public static int usedSize;
public MyArrayList(){
//不推荐这种写法,现在只是简单模拟一下
this.element = (E[]) new Object[10];
}
public void add(E e){//增添元素
if(isFull()){
this.element = Arrays.copyOf(element,element.length * 2);//2倍扩容
}
this.element[usedSize] = e;
usedSize++;
}
public boolean isEmpty(){
return usedSize > element.length;
}
public boolean isFull(){
return usedSize == element.length;
}
public void remove(int index){//删除第n个元素
if(index < 0 || index > usedSize)return;
for(int i = index; i < usedSize; i++){
element[i - 1] = element[i];
}
if(usedSize > 0) {
usedSize--;
}
}
public E search(int index){//查找第n个元素值
if(index < 0 || index > usedSize){
return null;
}
return element[index];
}
public String toString() {//重写toString方法
StringBuilder stringBuilder = new StringBuilder("[");
for (int i = 0; i < usedSize - 1; i++) {
stringBuilder.append(element[i]);
stringBuilder.append(",");
}
stringBuilder.append(element[usedSize-1]);
stringBuilder.append("]");
return stringBuilder.toString();
}
}
测试:
public static void main(String[] args) {
MyArrayList<Integer>list1 = new MyArrayList<Integer>();
list1.add(1);
list1.add(2);
list1.add(3);
list1.add(4);
list1.add(5);
System.out.println(list1);
list1.remove(1);
System.out.println(list1);
list1.remove(2);
list1.remove(3);
list1.remove(4);
list1.remove(5);
System.out.println(usedSize);
list1.remove(1);
System.out.println(list1);
System.out.println(list1.search(3));
}
结果:
熟练ArrayList-斗牛扑克牌
事先说明只能看牌,玩牌的逻辑还没有写,后续可能会出。写好玩牌逻辑后就是一个斗地主或者另外的扑克牌游戏。
public class Card {//牌类
public String suit;//花色
public String rank;//点数
public Card(String suit, String rank) {
this.suit = suit;
this.rank = rank;
}
@Override
public String toString() {
return "[" + suit + ":" + rank+"]";
}
}
import demo2.Card;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.Scanner;
public class Test {
static String suit[] = {"♠","♥","♣","♦"};
static String rank[] = {"1","2","3","4","5","6","7","8","9","10","J","Q","K"};
//没有大小王
//牌为 1,2,3,4,5,6,……J,Q,K
public static void buyCard(List<Card>list){//买牌
for(int i = 0; i < 4; i++){
for (int j = 0; j < 13; j++) {
Card card = new Card(suit[i],rank[j]);
list.add(i,card);
}
}
System.out.println("买来的牌"+list);
}
public static void swap(List<Card>list,int i ,int j){//洗牌交换顺序
Card tmp = list.get(i);
list.set(i,list.get(j));
list.set(j,tmp);
}
public static void shuffle(List<Card>list){//洗牌
//著名 的 洗牌代码,可以去搜搜,这里改长了点
int size = list.size();
Random random = new Random();
for(int i = size - 1; i > 0; i--){
int j = random.nextInt(i);
swap(list,i,j);
}
System.out.println("洗好的牌" + list);
}
//三个人轮流发五张牌
public static void lookCard(List<Card>list){//看牌
List<List<Card>>list1 = new ArrayList<>();
List<Card>list2 = new ArrayList<>();
List<Card>list3 = new ArrayList<>();
List<Card>list4 = new ArrayList<>();
list1.add(list2);
list1.add(list3);
list1.add(list4);
for(int i = 0; i < 5; i++){
for (int j = 0; j < 3; j++){
list1.get(j).add(list.remove(0));
}
}
System.out.println("第1个人的牌"+list1.get(0));
System.out.println("第2个人的牌"+list1.get(1));
System.out.println("第3个人的牌"+list1.get(2));
}
public static void play(){
List<Card>list = new ArrayList<>();
buyCard(list);
shuffle(list);
int i = 1;
while(list.size() > 15) {
System.out.println("============第"+i+"局的牌=============");
lookCard(list);
i++;
}
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
boolean game[] = {true,false};
while(true){
System.out.println("是否要进行斗牛游戏:0>是 1>否");
int i = scanner.nextInt();
if(game[i]){
play();
}else{
break;
}
}
}
}
测试:
本文收录专栏《数据结构》 。