12_集合框架

集合的概念

有提到：Arrays.asList()的集合不能add()和remove()问题

集合可以理解为存放数据的一个容器，本质上也是一个引用类型的变量。
集合与数组做对比
数组:用来存储一组数据类型相同的数据，数据类型可以是基本数据类型，引用类型(固定长度)
集合:一般配合泛型使用，也是存储一组数据类型相同的数据，数据类型只能是引用类型 (可变长度)
理解成动态数组。
集合与数组并不是等价的(集合的底层结构，有数组，链表，哈希表，红黑树)

集合的继承体系图解

List

List：有序，可重复集合
常用的实现类:
ArrayList/Vector：数组结构(查询修改效率高，插入，删除效率较低)
LinkedList :链表(查询修改效率较低，插入，删除效率较高)

ArrayList的应用

public static void main(String[] args) {
ArrayList<String> list=new ArrayList<>();
//1.往集合容器中顺序添加元素
list.add("charles");
list.add("jack");
list.add("rouse");
list.add("marry");
list.add("iis");
//2.往指定索引位置插入元素
list.add(0,"刘德华");
list.add(2,"王祖贤");
//list.add(10,"周星驰");//越界手动抛出了,throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
//3.根据指定索引位置修改元素
list.set(0,"周润发");
//4.根据指定索引位置删除元素
list.remove(0);
//4.根据元素删除内容
list.remove("jack");
//5.遍历集合一（简单for循环 根据索引取出集合中的数据）
for(int i=0;i<list.size();i++) {
System.out.println(list.get(i));
}
System.out.println("------------------增强for循环------------------");
//6.使用增强for循环遍历集合容器 ，如果不需要用到索引值.
for(String str:list) {
System.out.println(str);
}
System.out.println("-------------------迭代器----------------------");
//7.使用迭代器遍历集合容器
Iterator<String> it=list.iterator();
/*System.out.println("第一个元素:"+it.next());
System.out.println("第二个元素:"+it.next());
System.out.println("第三个元素:"+it.next());
System.out.println("第四个元素:"+it.next());
System.out.println(it.hasNext());//size==cursor 是否取完了集合中的元素 取完了false
没取完true
System.out.println("第五个元素:"+it.next());*/
/*while(it.hasNext()) {//判断有没有取完集合中的元素，取完了 返回false
String ele=it.next();//cursor++
//System.out.println(it.next());//cursor++ 如果是奇数次，会报异常NoSuchElementException
System.out.println(ele);
}*/
/*while (it.hasNext()) {//cursor=size
it.remove();
}*/
/*it.next();//cursor=1
lastRet=0
it.remove();//第一个元素
cursor=0
lastRet=-1*/
while(it.hasNext()) {
String name=it.next();
if("rouse".equals(name)||"marry".equals(name)){
it.remove();
}
}
//输出内容
System.out.println(list);
//1.扩展方法 addAll(Collection<? extends E> )
ArrayList<String> list1=new ArrayList<>();
list1.add("jj");
list1.add("kk");
list.addAll(list1);
System.out.println(list);
//2.扩展方法toArray();将集合转成数组
Object[] arr=list.toArray();
System.out.println(Arrays.toString(arr));
//3.数值类型的删除操作....
List<Integer> listNum=new ArrayList<>();
listNum.add(1);
listNum.add(0);
listNum.add(3);
listNum.add(2);
System.out.println(listNum);
//4.关于数值类型的删除
listNum.remove(0);//根据下标删除
Object obj=0;//根据元素删除怎么办?
listNum.remove(obj);
System.out.println(listNum);
}

问题将数组转成集合Arrays.asList(1,0,3,2,5,4)

不能调用add()和remove()方法，点击源码查看
public static <T> List<T> asList(T... a) {
return new ArrayList<>(a);
}
asList方法的实现，但是我们要注意，此ArrayList非我们认识的那个ArrayList，
而是Arrays类中的一个内部类,查看源码就可看见。
private static class ArrayList<E> extends AbstractList<E>
implements RandomAccess, java.io.Serializable
{
private static final long serialVersionUID = -2764017481108945198L;
private final E[] a;
ArrayList(E[] array) {
a = Objects.requireNonNull(array);
}
@Override
public int size() {
return a.length;
}
@Override
public Object[] toArray() {
return a.clone();
}
@Override
@SuppressWarnings("unchecked")
public <T> T[] toArray(T[] a) {
int size = size();
if (a.length < size)
return Arrays.copyOf(this.a, size,
(Class<? extends T[]>) a.getClass());
System.arraycopy(this.a, 0, a, 0, size);
if (a.length > size)
a[size] = null;
return a;
}
@Override
public E get(int index) {
return a[index];
}
@Override
public E set(int index, E element) {
E oldValue = a[index];
a[index] = element;
return oldValue;
}
@Override
public int indexOf(Object o) {
E[] a = this.a;
if (o == null) {
for (int i = 0; i < a.length; i++)
if (a[i] == null)
return i;
} else {
for (int i = 0; i < a.length; i++)
if (o.equals(a[i]))
return i;
}
return -1;
}
@Override
public boolean contains(Object o) {
return indexOf(o) != -1;
}
@Override
public Spliterator<E> spliterator() {
return Spliterators.spliterator(a, Spliterator.ORDERED);
}
@Override
public void forEach(Consumer<? super E> action) {
Objects.requireNonNull(action);
for (E e : a) {
action.accept(e);
}
}
@Override
public void replaceAll(UnaryOperator<E> operator) {
Objects.requireNonNull(operator);
E[] a = this.a;
for (int i = 0; i < a.length; i++) {
a[i] = operator.apply(a[i]);
}
}
@Override
public void sort(Comparator<? super E> c) {
Arrays.sort(a, c);
}
}
它压根没实现父类的add()和remove()方法,用的是父类AbstractList的默认实现。那我们再看父类的默认实现是啥，请看代码。
public boolean add(E e) {
add(size(), e);
return true;
}
public void add(int index, E element) {
throw new UnsupportedOperationException();
}

LinkedList应用

public static void main(String[] args) {
LinkedList<String> list=new LinkedList<>();
//1.逐后添加元素
list.add("zs");
list.add("ls");
list.add("ww");
list.add("zl");
//2.根据索引位置插入数据
list.add(2,"张三");
//3.根据指定的索引位置修改元素
list.set(2,"张无忌");
//4.根据索引值删除元素
list.remove(2);
//5.根据元素的值删除元素
list.remove("ww");
//链表独有的方法
//1.插入首元素
list.addFirst("张无忌");
list.addFirst("张翠山");
list.addFirst("张三丰");
//2.插入末尾元素
list.addLast("孙悟空");
list.addLast("猪悟能");
//3.删除首元素
list.removeFirst();
//4.删除末尾元素
list.removeLast();
//5.获取首元素
System.out.println(list.getFirst());
//6.获取末尾元素
System.out.println(list.getLast());
System.out.println(list);
//7.遍历元素一
for(int i=0;i<list.size();i++) {
System.out.println(list.get(i));
}
//8.遍历元素二
for(String str:list) {
System.out.println(str);
}
//9.迭代器
Iterator<String> it=list.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}

集合工具类Collections

public static void main(String[] args) {
List<Integer> list=new ArrayList<Integer>();
list.add(200);
list.add(100);
list.add(500);
list.add(300);
list.add(400);
System.out.println("未排序之前:"+list);
//1.反转
Collections.reverse(list);
System.out.println("反转之后:"+list);
//2.交换顺序
将最后一个元素与第一个元素交换顺序。
Collections.swap(list,0, list.size()-1);
System.out.println("交换顺序之后:"+list);
//3.随机打乱集合中的顺序
Collections.shuffle(list);
System.out.println("随机打乱集合中的顺序:"+list);
//4.最大值 与最小值
System.out.println("最高分:"+Collections.max(list));
System.out.println("最低分:"+Collections.min(list));
//5.排序
Collections.sort(list);
System.out.println("排序之后:"+list);
}

比较器

引入：
但是如果集合中存入的数据为自定义类型比如Student，Teacher，Student(name,age)
name="jack" age=18;
？
name="rouse" age=20;
默认情况下自定义的类型是无法比较大小的，所以如果集合中保存的是自定义的对象类型，则无法进行排序，甚至无法得到最大值，以及最小值
ArrayList<Student> list=new ....
Collections.sort(list)?//不可以
Collections.max(list)?//不可以
Collections.min(list)?//不可以
如果想要进行排序，那么必须使用比较器。
比较的作用:可以通过比较器去自定义对象比较的规则(谁大谁小自己定义)，只要加了比较器的自定义类，才可以使用集合工具类中的sort()排序方法，以及最大值，最小值的方法。
Comparable:自比较
public class Student implements Comparable<Student>{
private int age;
private String name;
private int score;
public Student() {
super();
}
public Student(int age, String name, int score) {
super();
this.age = age;
this.name = name;
this.score = score;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
@Override
public String toString() {
return "Student [age=" + age + ", name=" + name + ", score=" + score + "]";
}
//1.按照成绩进行顺序排列
//2.如果成绩一样按照年龄进行倒序排列
@Override
public int compareTo(Student stu) {
if(this.getScore()==stu.getScore()) {
return stu.getAge()-this.getAge();
}
return this.getScore()-stu.getScore();
}
//1.先按照成绩进行顺序排列
//2.如果成绩一样按照名字进行顺序排序
@Override
public int compareTo(Student stu) {
if(stu.getScore()==this.getScore()) {
//str1.compareTo(str2); str1>str2
1
str1==str2 0
str1<str2
-1
return this.getName().compareTo(stu.getName());
}
return this.getScore()-stu.getScore();
}
}
Comparator:类比较
public static void main(String[] args) {
List<Student> list=new ArrayList<>();
list.add(new Student(18,"jack1",87));
list.add(new Student(20,"jack2",57));
list.add(new Student(17,"jack3",97));
list.add(new Student(18,"jack4",67));
list.add(new Student(16,"jack5",87));
System.out.println("排序之前:"+list);
Collections.sort(list,new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
//升序
return o1.getScore()-o2.getScore();
}
});
System.out.println("排序之后:"+list);
//1.获取的是最后一个元素(顺序排才能拿到最大值)
Student stu1=Collections.max(list,new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return o1.getScore()-o2.getScore();
}
});
//2.获取的是第一个元素(顺序排完之后)
Student stu2=Collections.min(list,new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return o1.getScore()-o2.getScore();
}
});
System.out.println("最高分的学生信息:"+stu1);
System.out.println("最低分的学生信息:"+stu2);
}

最后

以上就是飘逸百合为你收集整理的12_集合框架的全部内容，希望文章能够帮你解决12_集合框架所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。