java中List集合，ArrayList集合、LinkedList集合、模拟斗地主

最新推荐文章于 2022-07-21 15:19:19 发布

骑恐龙去钓鱼

最新推荐文章于 2022-07-21 15:19:19 发布

阅读量243

点赞数

文章标签： java 数据结构

本文链接：https://blog.csdn.net/qq_45018290/article/details/107489334

版权

List接口

java.util.List接口继承Collection接口
接口的特点：

有序的集合
。有序，元素在集合中，存储和取出的顺序一致
允许存储重复元素的集合
该接口中都是带有索引的
该接口的所有实现类，都具备以上三个特点

接口方法

带有索引的方法学习

add(int index,存储元素)将元素，存储到指定的索引上
元素 get(int index)返回指定索引上的元素
元素 remove(int index)移除指定索引上的元素，返回被删除之前的元素
元素 set(int index，修改的元素)修改指定索引上的元素，返回被修改之前的
List sublist(int begin，int end)截取集合的一部分，包含开始索引，不包含结束索引

public static void main(String [ ] args) {
	myAdd();
	mySubList();
}
public static void myAdd() {
	//接口多态，创建对象
	List<String> list = new ArrayList<String>();
	//集合存储元素
	list.add("a");
	list.add("b");
	list.add("c");
	System. out . println(list);
	//在指定的索引上添加元素
	list.add(2, "d");
	System. out . println(list) ;
	//获取指定索引上的元素
	String str = list.get(0);
	System . out. println(str) ;
	//移除1索引上的元素
	String s=list . remove(1);
	System. out. println(s);
	System. out. println(list);
	//修改2索引上的元素，大写C
	String st = list.set(2, "C"); 
	System. out . println(st);
	System. out . println(list);
	
}
public static void mySubList() {
	//接口多态, 创建对象
	List<String> list = new ArrayList<String>();
	//集合存储元素
	list.add("a");
	list.add("b");
	list.add("c");
	list . add("d");
	list . add("e");
	list.add("f");
	System. out . println(list);
	//截取集合的元素
	List<String> newList= list. subList(1, 4);
	System. out . println(newList) ;
}

List转Set

List<String> myList =new ArrayList()<String>;
myList.add("1");
myList.add("1");
Set result = new HashSet(myList);

Set转List

String[] str = new String[]{"Tom", "Bob", "Jane"};
Set<String> set = new HashSet<>(Arrays.asList(str));
List<String> result = new ArrayList<>(set);

数组转List

String[] str = new String[]{"Tom", "Bob", "Jane"};
List list = Arrays.asList(str);

数组转Set

String[] str = new String[]{"Tom", "Bob", "Jane"};
Set<String> set = new HashSet<>(Arrays.asList(str));

List转数组

String[] str = new String[]{"Tom", "Bob", "Jane"};
List list = Arrays.asList(str); 
Object[] result = list.toArray();

Set转数组

String[] str = new String[]{"Tom", "Bob", "Jane"};
Set<String> set = new HashSet<>(Arrays.asList(str)); 
Object[] result = set.toArray();

ArrayList集合

java. uti1. ArrayList集合,类实现了接口List (有序,索引，重复)
ArrayList集合.底层是采用数组结构实现，大小可变数组(复制)
查询速度快,增删速度慢
ArrayList是一个线程不安全的集合,运行速度快

ArrayList集合用法

集合的构造方法：new 无参数的构造方法
。创建长度为10个的集合，ArrayList底层是数组，数组长度是10
集合的构造方法：new 有参数的构造方法，传递int类型参数
。参数是指定数组的长度
向集合中存储元素，取出元素

public static void main(String[] args) {
	//定义集合,存储自定义的对象Person
	ArrayList<Person> array = new ArrayList<Person>();
	array.add( new Person("张三",20) );
	array. add( new Person("李四",21) );
	array.add( new Person("王五",22) );
	//迭代器遍历
	Iterator<Person> it = array .iterator();
	while(it. hasNext()) {
		Person p = it.next();
		System . out .println(p);
	}
	/*
	*List接口实现类,ArrayList集合具有索引
	*利用索引来遍历集合方法size() 
	*get(索引)返回对应的元素
	*/
	for(int i = 0 ; i < array.size() ; i++) {
		Person p = array.get(i);
	  	System . out .println(p);
	}
}

源码分析

ArrayList集合内部是数组

transient Object[] elementData; object类型的对象数组，可以存储任意类型的对象
private static final int DEFAULT_ CAPACITY = 10;

构造方法

public ArrayList(){
	this. elementData = DEFAULTCAPACITY_ EMPTY_ ELEMENTDATA; 空数组
}

add方法

pub1ic boolean add(E e) {
	ensureCapacityInternal(size + 1); // Increments modCount!!
	elementBata[size++] = e;//数组元素 赋值
	return true ;
}

ensureCapacityInternal(size + 1)方法

private void ensurecapacityInternal(int mincapacity) {
	ensureExplicitcapacity(calculateCapacity (elementData, mincapacity));
}

calculateCapacity方法

private static int calculateCapacity(object[] elementData,int mincapacity) {
	if (elementData == DEFAULTCAPACITY _EMPTY_ ELEMENTDATAX {
		return Math. max(DEFAULT_ CAPACITY, mincapacity);
	}
	return mincapacity;
}

ensureExplicitcapacity方法

private void ensureExplicitcapacity(int mincapacity) {
	modcount++;
	// overflow-conscious code
	if (mincapacity - elementData. 1ength > 0)
		grow(mincapacity);
}

grow方法

private void grow(int minCapacity) {
	// overflow-conscious code
	老容量0 = 存储元素数组的长度 =0
	int oldCapacity = elementData. length;
	新容量 0 =老+(老>>1)/2
	int newCapacity = oldCapacity + （oldCapacity >> 1);
	if (newCapacity - minCapacity < 0)
	newCapacity = mincapacity; 10
	if (newCapacity - MAX_ ARRAY_ SIZE > 0)
	newCapacity = hugeCapacity (mincapacity);
	// minCapacity is usual1y close to size， so this is a win:
	elementData = Arrays. copyof (elementData, newcapacity);
}

ArrayList集合数组扩容新容量=老容量+老容量/2

LinkedList集合

java. util.LinkedList实现List接口(有序，索引，重复)
底层数据结构是链表结构，双向链表
查询速度慢，增删速度快
线程不安全的,运行速度快
特性的内容：专门有方法，操作链表的开头元素和结尾元素

LinkedList特有方法

向链表的开头和结尾插入元素
。addFirst(元素)链表开头插入元素
。addLast(元素)链表结尾插入元素
获取链表的开头和结尾元素
。元素 getFirst()获取链表的开头元素
。元素 getLast()获取链表的结尾元素
删除链表的开头和结尾元素
。元素 removeFirst()获取链表的开头元素
。元素 removelast() 获取链表的结尾元素
push和pop方法
。push(元素) 元素压入栈中
。元素 pop()栈中弹出元素

public static void main(String[] args) {
	myAdd( );
	myGet();
	myRemove();
	myPushPop();
}
public static void myGet() {
	LinkedList<String> link = new LinkedList<String>();
	link.add("a");
	link.add("b");
	link.add("c");
	link.add("d");
	System. out . println(link);
	//获取开头和结尾元素
	String first = . link. getFirst();
	String last = link.getLast();
	System. out. println(first);
	System. out. println(last);
}
public static void myAdd() {
	LinkedList<String> link = new LinkedList<String>();
	link.add("a");
	link.add("b");
	link.add("c");
	link.add("d");
	System. out . println(link);
	//开头插入元素
	link .addFirst("e");
	System. out . println(link);
	//尾部插入元素
	link.addLast("f");//add和addLast 没区别
	System. out . println(link) ;
}
pub1ic static void myRemove() {
	LinkedList<String> link = new LinkedList<String>();
	link. add("a");
	link. add("b");
	link.add("c");
	link .add("d");
	System. out . println(link);
	//移除链表开头和结尾
	String first = link. removeFirst();
	String last = link. removelast( );
	System. out . println(first);
	System. out . println(last);
	System. out . println(link) ;
}
public static void myPushPop() {
	LinkedList<String> link = new LinkedList<String>();
	link.add("a");
	link.add("b");
	link.add("c");
	link.add("d");
	System. out. println(link);
	//栈中推入元素
	link.push("e");
	System. out . println(link);
	//栈中弹出元素
	String pop = link.pop(); //移除开头
	System. out . println(pop);
	System. out . println(link);
}

LinkedList源码

成员变量

transient Node<E> first;//链表头节点元素
transient Node<E> last;//链表尾节点元素

内部类

Node节点对象
private static class Node<E> {
E item; //存储元素
Node<E> next; //记录下一个元素地址
Node<E> prev; //记录上一个元素地址
Node (Node<E> prev， E element，Node<E> next) {
	this. item = element;
	this.next = next;
	this.prev = prev;
	}
}

add方法

void 1inkLast(E e) {//记住最后一个节点
final Node<E> l = last;
final Node<E> newNode = new Node<>(1, e，nu11);
last = newNode;//新建立节点对象，赋值给最后一个节点
if (l == nu11)
	first = newNode ;
else
	l. next = newNode ;
size++;
modCount++;
}

get(1)方法

Node<E> node(int index) {
	if (index < (size >> 1)) {
		Node<E> x = first;
		for(inti=0;i<index;i++)
			X = x.next;
		return x;
	} else {
		Node<E> X = last;
		for(inti=size-1;i>index;i--)
			x = x.prev;
		return x;
	}
}

模拟游戏斗地主

斗地主：准备牌，洗牌，发牌，看牌
功能分析:准备牌(图片)字符串替代
定义54个字符串(否)
牌的规律: 4个花色和13个点数构成4* 13= 52
一个花色,和13个点数组合:外循环是花色,内循环点数,形成了52个字符串
容器，存储54个字符串
功能分析:洗牌
本质是将集合中保存的字符串的顺序打乱
Collections类,静态方法shuffle(集合)集合元素随机排列
功能分析:发牌
集合的操作:存储54个字符串的容器中,取出一个字符串,存储到玩家的集合保存
利用集合元素索引，%3，决定发给哪个玩家集合中
功能分析:看牌
遍历集合
方法抽取：定义方法，实现遍历，需要遍历哪个传递哪个

public static void main(String[] args) {
	//定义集合,存储字符串(牌)
	ArrayList<String> arrayPoker = new ArrayList<String>();
	//一个花色,和13个点数组合:外循环是花色，内循环点数,形成了52个字符串
	//数组存储花
	String[] colors={"♥","♠","♣","♦"};
	//数组存储点数
	String[] numbers = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
	//外循环是花色
	for(int i = 0 ; i < colors.length; i++) {
		//System. out. println(colors[i]);
		//内循环点数
		for(int j = 0 ; j < numbers.length ;j++) {
			//拼接字符串,存储到集合
			arrayPoker . add( colors [i]+numbers[j]);
		}
	}
	//add方法添加王牌
	arrayPoker.add("🃏");
	arrayPoker . add("🃏");
	//Collections类,集合元素的随机排列
	Collections . shuffle(arrayPoker) ;
	//定义4个集合,存储3个玩家的牌，存储底牌
	ArrayList<String> player1 = new ArrayList<String>();
	ArrayList<String> player2 = new ArrayList<String>();
	ArrayList<String> player3 = new ArrayList<String>();
	ArrayList<String> bottom = new ArrayList<String>();
	//发牌:遍历牌盒集合,利用索引%3
	for(int i = 0 ; i < arrayPoker.size() ; i++) {
		if(i<3){
		bottom. add( arrayPoker .get(i) );
		}
		//判断索引%3
		else if( i%3==0){
		//发到玩家1手里
		player1. add( arrayPoker.get(i) );
		}
		else if ( i%3==1){
		//发到玩家2手里
		player2. add( arrayPoker .get(i) );
		}
		else if ( i%3==2){
		//发到玩家3手里
		player3. add( arrayPoker .get(i) );
		}
	}
	//调用看牌方法
	look("周星驰",player1);
	look( "周润发" ,player2);
	look( "周杰伦" , player3);
	look("底牌" , bottom);
}
//定义方法,传递集合,遍历
public static void look(String name,ArrayList<String> array) {
	System . out. print (name+"::");
	for(int i = 0 ; i < array.size() ; i++) {
		System . out .print(array.get(i)+" ");
	}
	System . out .println();
}

骑恐龙去钓鱼

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java中List集合，ArrayList集合、LinkedList集合、模拟斗地主

List接口java.util.List接口继承Collection接口接口的特点：有序的集合。有序，元素在集合中，存储和取出的顺序一致允许存储重复元素的集合该接口中都是带有索引的该接口的所有实现类，都具备以上三个特点接口方法带有索引的方法学习add(int index,存储元素)将元素，存储到指定的索引上元素 get(int index)返回指定索引上的元素元素 remove(int index)移除指定索引上的元素，返回被删除之前的元素元素 set(int index，修
复制链接

扫一扫