2021-07-22

集合
List接口： 有序的、不唯一
ArrayList：
特点： 有序、不唯一

数据结构： Object数组

ArrayList：包装类
作用一：ArrayList是基于Object[]实现的，所以该只能装引用数据类型，基本数据类型要想装进集合，需要将基本数据类型进行类的包装。

作用二：包装类中有将String类型转换为对应的基本数据类型的方法。
ArrayList的基本用法和特点
特点：
有序的：按照添加的顺序
不唯一：同一个元素可以装多次
1:如何创建泛型对象
ArrayList<泛型> list=new ArrayList<>();

2:如何添加元素：
一次添加一个元素：
list.add(元素);
一次添加多个元素：
Collections.addAll(集合，元素，元素，…);
3:得到集合元素的个数
list.size();
4:得到某一个元素
list.get(下标);
5：如何判断集合里面是否出现指定元素
list.contains();
6:遍历
for+下标
for(int x=0;x<list.size();x++){
//x->下标
//list.get(元素)；
}
foreache
for(集合的泛型 x :list){
//x->元素
}
迭代器********（重点）
for(得到迭代器对象;判断迭代器上面是否还有下一个元素;){
取出下一个元素
}

for(Iterator<泛型>car=list.iterator();car.hasNext;){
car.next();->元素
}

ArrayList 如何删除元素：
list.remove(int 下标);
下标指向谁就删除谁，如果下标不存在就抛出异常。
清空集合：list.clear();
list.remove(元素->参照物);
指定元素进行删除
*：一个remove只能删除一个对象。

ArrayList
1:ArrayList类里面的remove(元素)的方法
底层需要尊重equals比较机制

	当我们想要删除一个元素的时候 底层拿着这个元素
	和集合里面的每一个元素做equals比较

2:谁主张谁举证
要被删除的对象会主动调用他自己类的equals方法
和集合里面的每一个元素做比较

3:当我们使用迭代器遍历集合的过程中 不允许对集合
的整体进行添加、删除操作 否则出发CME异常

	如果想要在遍历的过程中进行删除
	只能使用迭代器的删除方法：car.remove();

4:构造方法：
ArrayList list = new ArrayList(int 数组空间大小);
ArrayList list = new ArrayList();//数组默认开辟10块空间

	集合会自动扩容：
		jdk6.0及之前	x * 3 / 2 + 1
						10 -> 16 -> 25....

		jdk7.0及之后	x + (x >> 1)
						10 -> 15 -> 22....

	在项目开发的时候 尽量避免扩容：
		1：创建一个更大的新的数组对象
		2：将老数组里面的元素复制到新数组里面
		3：改变引用指向
		4：回收老数组对象
		5：继续添加元素

	扩容：list.ensureCapacity(数组空间)
	缩容：list.trimToSize()

---

Vector语法和ArrayList一模一样的

---

面试题：
ArrayList和Vector之间的区别？
1:同步特性不同
Vector同一时间允许一个线程进行访问，效率较低，但是不会发生并发错误。
ArrayList同一时间允许多个线程进行访问，效率高，但是可能会发生并发错误。

---

jdk5.0开始 集合的工具类[Collections]里面提供一个方法synchronizedList
可以将线程不安全的ArrayList集合变成线程安全的集合对象
于是Vector渐渐被淘汰了
2：扩容不同
ArrayList:分版本
jdk6.0及之前 x * 3 / 2 + 1
jdk7.0及之后 x + (x >> 1)

Vector:分构造方法
Vector(10) -> 2倍扩容 10 -》 20 -》 40…
Vector(10,3) -> 定长扩容 10 -》 13 -》 16…

3:出现的版本不同
Vector:since jdk1.0
ArrayList:since jdk1.2

---

LinkedList语法和ArrayList一模一样
面试题：
ArrayList和LinkedList之间的区别？
ArrayList和LinkedList底层数据结构不同 导致优劣势不同
ArrayList：底层是基于数组实现的
优点：随机访问 遍历查找效率高
缺点：添加删除元素的时候效率低
LinkedList：底层是基于链表实现的

 优点：添加删除元素的时候效率高。
 缺点：随机访问 遍历查找效率低[从下标0开始找起]

---

Stack: 用数组模拟栈结构

代码1
import java.util.*;
public class Daycare{
public static void main(String[] args){
//ArrayList Collections.addAll(集合,元素,…)
//创建一个集合对象装名字
ArrayList list=new ArrayList<>();
//一次添加一个元素的方式：添加：Andy Lee
Collections.addAll(list,“Andy”,“Lee”);
//统计集合里面有几个人的姓名
System.out.println(“人的个数：”+list.size());
//打印第一个人的姓名
System.out.println(“第一个人的名字：”+list.get(0));
//判断集合里面是否出现Lee的名字
System.out.println(list.contains(“Lee”));
//使用两种不同的方式打印 所有以A开头的名字
for(String name:list){
if(name.charAt(0)==‘A’){
System.out.println(name);
}
}
for(String name:list){
if(name.startsWith(“A”)){
System.out.println(name);
}
}
//用迭代器
for(Iterator car=list.iterator();car.hasNext()😉{
String name=car.next();
if(name.startsWith(“A”)){
System.out.println(name);
}

	  }
   }

}
代码2
import java.util.*;
public class Daycare{
public static void main(String[] args){
//老筐 里面装的水果 有些重复的
ArrayList list=new ArrayList<>();
Collections.addAll(list,56,77,77,90,56,28);
ArrayListlist1=new ArrayList<>();
//将重复元素去除
for(Integer i:list){
if(!(list1.contains(i))){
list1.add(i);
}
}
System.out.println(list1);
}
}

代码3
import java.util.*;
public class Daycare{
public static void main(String[] args){
ArrayList list = new ArrayList<>();
Teacher t1 = new Teacher(“周老师”,30,5000.0);
Teacher t2 = new Teacher(“王老师”,22,5500);
Teacher t3 = new Teacher(“周老师”,22,5500.0);
Teacher t4 = new Teacher(“周老师”,30,5500);
//要求将t1 t2 t3三个老师装进集合里面
Collections.addAll(list,t1,t2,t3);
//要求删除t4
//删除t4的操作 将集合里面的t3删掉
list.remove(t4);
System.out.println(list);
}

}
class Teacher{
String name;
int age;
double salary;
public Teacher(String name,int age,double salary){
this.name = name;
this.age = age;
this.salary = salary;
}
@Override
public String toString(){
return name+" “+age+” "+salary;
}
@Override
public boolean equals(Object obj){
if(objnull)return false;
if(!(obj instanceof Teacher) )return false;
if(objthis)return true;
return this.name.equals(((Teacher)obj).name)&&this.salary==((Teacher)obj).salary;
}
}

代码4
import java.util.*;
public class Daycare{
public static void main(String[] args){
ArrayList list = new ArrayList<>();
Food f1 = new Food(“凉拌黃瓜”,18,“凉菜”);
Food f2 = new Food(“皮蛋豆腐”,22,“凉菜”);
Food f3 = new Food(“辣椒炒肉”,28,“热菜”);
Food f4 = new Food(“凉拌海带”,19,“凉菜”);
Food f5 = new Food(“小鸡炖蘑菇”,45,“热菜”);
// Food f6 = new Food(“小鸡炖蘑菇”,45,“l菜”);
//将所有的菜全部装进集合里面
Collections.addAll(list,f1,f2,f3,f4,f5);
//由于天气太冷了 删除集合里面的第三道凉菜
int count=0;
for(Iterator car=list.iterator();car.hasNext()😉{
Food f=car.next();
if(f.type.equals(“凉菜”)){
count++;
/**
if(count3){
car.remove();
}
*/
}
if(count3){
car.remove();
break;
}
}

 //最终打印集合对象 显示
 //[凉拌黄瓜:凉菜,皮蛋豆腐:凉菜,辣椒炒肉:热菜,小鸡炖蘑菇:热菜]

}
}
class Food{
String name;
double price;
String type;
public Food(String name,double price,String type){
this.name=name;
this.price=price;
this.type=type;
}
}

代码5

import java.util.*;
public class Daycare{
public static void main(String[] args){
String str = “张三:66 李四:82 王五:59 张三丰:77”;
//将班级总分算出来
int sum=0;
String[]str1=str.split(" “);
for(String x:str1){
String[]str2=x.split(”😊;
int a=Integer.parseInt(str2[1]);
sum+=a;
}
System.out.println(sum);
//统计有几个人的成绩 > 平均分
int count=0;
for(String x:str1){
String[]str2=x.split("😊;
int a=Integer.parseInt(str2[1]);
if(a>(sum/str.length())){
count++;
}
}
System.out.println(count+“个”);
//打印最高分和他的名字
int max=0;
String name=" “;
for(String x:str1){
String[]str2=x.split(”😊;
int a=Integer.parseInt(str2[1]);
if(a>max){
max=a;
name=x;
}
}
System.out.println(“姓名：”+name+“分数：”+max);
}
}

代码6
import java.util.;
public class Exec68{
public static void main(String[] args){
ArrayList list=new ArrayList<>();
list.add(“天王盖地虎[45]少盐”);
list.add(“斩青龙[18]多放蒜”);
list.add(“辣椒炒肉[23]不放肉”);
list.add(“西红柿鸡蛋汤[20]放两个鸡蛋”);
list.add(“米饭[2]8”);
//向厨师展示信息：
//菜名字 ：菜要求
//由于今天西红柿断货 所有和西红柿有关的菜全部删除
//由于出门钱带的不多 删除价格>30的菜
//计算这顿饭花费多少钱
for(String str:list){
int a=str.indexOf("[");
int b=str.indexOf("]");
String str1=str.substring(0,a);
String str2=str.substring(b+1);
String str3=str1+" “+str2;
System.out.println(str3);
}
for(Iterator car=list.iterator();car.hasNext()😉{
String a=car.next();
if(a.contains(“西红柿”)){
car.remove();
}
}
System.out.println(list);
for(Iterator car=list.iterator();car.hasNext()😉{
String g=car.next();
int s=g.indexOf(”[");
int d=g.indexOf("]");
String str5=g.substring(s+1,d);
int a=Integer.parseInt(str5);
if(a>30){
car.remove();
}
}
System.out.println(list);
int sum=0;
for(Iterator car=list.iterator();car.hasNext()😉{
String h=car.next();
int q=h.indexOf("[");
int w=h.indexOf("]");
String str5=h.substring(q+1,w);
int e=Integer.parseInt(str5);
if(e==2){
e=28;
}
sum+=e;
}
System.out.println(“一共花了”+sum);
}
}
————————————————
版权声明：本文为CSDN博主「大甦」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/sukelys/article/details/103395232