Java集合详解（list去重、list遍历）

Java集合

---

前言

什么是集合?集合的遍历读取、集合list的去重、排序函数、应用场景，集合和数组的区别，你想要的这都有

⼀、Collection集合

概念

集合是java中提供的⼀种容器，可以⽤来存储多个数据。
数组：存储⼀组相同数据类型的数据结构。

• 内存容量：存储长度初始定好了（定⻓）
  集合：动态存放多个对象。
• 动态：集合的⼤⼩随着存储的数据量⽽改变。
• 内存容量：0-多个数据
• 对象：存储类的实例。基本数据类型—>包装类对象。

集合框架

集合常用函数

方法	描述
boolean add(Object obj)	添加⼀个对象数据
boolean addAll(Collection c)	将⼀个集合中的所有对象添加到此集合中
void clear()	清空此集合中的所有对象
boolean contains(Object o)	检查此集合中是否包含o对象
boolean equals(Object o)	⽐较此集合是否与指定对象相等
boolean isEmpty()	判断此集合是否为空
boolean remove(Object o)	在此集合中移除o对象
int size()	返回此集合中的元素个数
Object[] toArray()	将此集合转换成数组

示例：

//step1:创建⼀个容器
Collection collection1 = new ArrayList();
System.out.println(collection1);
//step2:往容器中添加元素
boolean flag = collection1.add("abc");//返回⼀个boolean值，判断是否添加成
功
System.out.println("flag:"+flag);
//System.out.println(collection1);
collection1.add(true);
collection1.add(123);//---->int---->Integer---->Object
System.out.println(collection1);//重写了toString()⽅法
System.out.println("集合的元素个数："+collection1.size());
System.out.println("-----------------");
Collection c2 = new ArrayList();
c2.add(12);
c2.add(45);
c2.add(67);
collection1.addAll(c2);//将集合中元素⼀次性添加到⽬标集合中
System.out.println(collection1);
System.out.println("---------");
System.out.println(collection1.contains("abc"));
System.out.println(collection1.containsAll(c2));//判断是否包含集合c2中所
有的元素
System.out.println("-------------");
System.out.println(collection1.isEmpty());//判断集合是否为空
System.out.println("------------");
collection1.remove(true);//删除集合中的⼀个元素
collection1.removeAll(c2);//删除指定的集合中所有的元素
System.out.println(collection1);
System.out.println("--------------");
collection1.clear();
System.out.println("------------");
Collection c3 = new ArrayList();
c3.add(123);
c3.add(345);
collection1.add(123);
collection1.add(true);
collection1.add("abc");
System.out.println(collection1);
collection1.retainAll(c3);//交集：仅保留此集合中包含在指定集合中的元素
System.out.println(collection1);

Collections⼯具类

常⽤⽅法：

⽅法	描述
public static void reverse(List<?> list)	反转集合中元素的顺序
public static void shuffle(List<?> list)	随机重置集合元素的顺序
public static void sort(List list)	升序排序（元素类型必须实现Comparable接⼝）
public static int binarySearch( list, T key)	⼆分查找

示例：

List<String> list1 = new ArrayList<>();
//向指定的集合中添加元素
Collections.addAll(list1,"aaa","bbb","ccc","ddd");
System.out.println(list1);
//找到指定的元素的下标
int index = Collections.binarySearch(list1,"bbb");
System.out.println("index:"+index);
Collections.reverse(list1);//反转指定列表中元素的顺序。
System.out.println(list1);
//使⽤默认的随机源随机排列指定的列表。
Collections.shuffle(list1);
System.out.println(list1);
//排序
Collections.sort(list1);
System.out.println(list1);

Iterator迭代器

在程序开发中，经常需要遍历集合中的所有元素。
迭代：即Collection集合元素的通⽤获取⽅式。在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出出来。⼀直把集合中的所有元素全部取出。这种取出⽅式专业术语称为迭代。
Iterator 接⼝也是Java集合中的⼀员，但它与 Collection、Map 接⼝有所不同， Collection 接⼝与Map 接⼝主要⽤于存储元素，⽽ Iterator 主要⽤于迭代访问（即遍历） Collection 中的元素，因此Iterator 对象也被称为迭代器
获取迭代器的⽅法：
public Iterator iterator(): 获取集合对应的迭代器，⽤来遍历集合中的元素的。
Iterator接⼝的常⽤⽅法如下：
public E next():返回迭代的下⼀个元素。
public boolean hasNext():如果仍有元素可以迭代，则返回 true。
step1：先获取集合上的迭代器
Iterator it = c1.iterator();
step2：先判断迭代器后是否有数据
it.hasNext()–>boolean
step3：通过迭代器获取集合的元素
it.next()—>E
示例：

Collection<String> c1 = new ArrayList<>();
c1.add("aa");
c1.add("bb");
c1.add("cc");
c1.add("dd");
//3.2使⽤迭代器(迭代器专⻔⽤来遍历集合的⼀种⽅式)
//hasNext();有没有下⼀个元素，
//next();获取下⼀个元素
//remove();删除当前元素
Iterator<String> iterator = c1.iterator();
if(iterator.hasNext()){
System.out.println(iterator.next());
//不能使⽤collection删除⽅法，因为遍历同时不能使⽤集合删除⽅法，否则出现并发修改异常。
//可以使⽤迭代器的删除⽅法
//c1.remove(s);
//iterator.remove();
}
System.out.println(iterator.next());
System.out.println(iterator.next());
System.out.println(iterator.next());
System.out.println(iterator.next());
System.out.println(iterator.next());//java.util.NoSuchElementException

二、集合

List接⼝

特点：有序、有下标、元素可以重复。
List作为Collection集合的⼦接⼝，不但继承了Collection接⼝中的全部⽅法，⽽且还增加了⼀些根据元素索引来操作集合的特有⽅法，如下：
public void add(int index, E element) : 将指定的元素，添加到该集合中的指定位置上。
public E get(int index) :返回集合中指定位置的元素。
public E remove(int index) : 移除列表中指定位置的元素, 返回的是被移除的元素。
public E set(int index, E element) :⽤指定元素替换集合中指定位置的元素,返回值的更新前的元素。
List集合特有的⽅法都是跟索引相关

List实现类

ArrayList
java.util.ArrayList 集合数据存储的结构是数组结构。元素增删慢，查找快，由于⽇常开发中使⽤最多的功能为查询数据、遍历数据，所以 ArrayList 是最常⽤的集合。
优点：查询数据、遍历数据效率很⾼。它使⽤索引快速定位对象。
缺点：是插⼊或删除元素相对于LinkedList较慢。 因为⽤了数组，需要移动后⾯的元素以调整索引的顺序。

示例：

List<String> list = new ArrayList();
list.add("wowo");
list.add("aa");
list.add("dd");
System.out.println(list);
list.add(1,"cc");//在指定的下标添加元素
System.out.println(list);
String ele = list.get(1);//获取指定下标的元素；
System.out.println("ele:"+ele);
int index = list.indexOf("ada");//返回元素所在的下标；
System.out.println("index:"+index);
String remove = list.remove(2);//删除指定下标的元素
System.out.println("remove:"+remove);
System.out.println(list);
boolean flag = list.remove("ads");
System.out.println("flag:"+flag);
System.out.println(list);
list.set(1,"XXXX");//设置指定下标的元素
System.out.println(list);
list.add("hello");
list.add("wowo");
System.out.println(list);
List sublist = list.subList(2,4);//返回⼀个指定下标范围之间的⼦集
System.out.println(sublist);
Object[] objects = list.toArray();
System.out.println(Arrays.toString(objects));

LinkedList
java.util.LinkedList 集合数据存储的结构是链表结构，⽅便元素添加、删除的集合，访问遍历相对于ArrayList较慢。

Set接⼝
特点：⽆序、⽆下标、元素不可重复。
⽅法：全部继承⾃Collection中的⽅法。
使⽤foreach循环遍历： for(数据类型 局部变量 : 集合名){ //循环内部的局部变量，代表当次循环从集合中取出的对象 }
Set实现类
HashSet
特点：⽆序，去重
JDK提供的类：String，Integer可以直接添加到HashSet,⾃动去重；
⾃定义类：⾃⼰重写hashCode()和equals()，必须同时重写。
⾃定义类

package part3;
import java.util.Objects;
public class Person implements Comparable<Person> {
private String name;
private int age;
@Override
public int compareTo(Person o) {
if(age>o.getAge()){
return 1;
}else if(age<o.getAge()){
return -1;
}else{
return name.compareTo(o.getName());
}
//return 0;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age &&
name.equals(person.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
public Person(){}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}

示例：

Set<String> set1 = new HashSet<>();
set1.add("aaa");
set1.add("bbb");
set1.add("ccc");
set1.add("ddd");
System.out.println(set1);
boolean flag = set1.add("aaa");//添加的时候，判断是否重复
System.out.println("flag:"+flag);
System.out.println(set1);
System.out.println("-------------------");
Set<Integer> set2 = new HashSet<>();
set2.add(1);
set2.add(2);
set2.add(3);
set2.add(2);
System.out.println(set2);
Person p1 =new Person("张三",23);
Person p2 = new Person("lisi",56);
Person p3 = new Person("张三",23);
Set<Person> set3 = new HashSet<>();
set3.add(p1);
set3.add(p2);
set3.add(p3);
System.out.println(set3);

TreeSet
特点：有序，去重
JDK提供的类String,Integer，已经实现了这个Comparable接⼝；⾃动有序去重；
⾃定义的类：实现Comparable接⼝的compareTo⽅法，在这个⽅法⾥写相应的排序的规则
示例：

Set<String> set1 =new TreeSet<>();
set1.add("aaa");
set1.add("ccc");
set1.add("ddd");
set1.add("bbb");
System.out.println(set1);
boolean flag = set1.add("aaa");
System.out.println("flag:"+flag);
System.out.println(set1);
Person p1 =new Person("张三",23);
Person p2 = new Person("lisi",56);
Person p3 = new Person("wowo",23);
Set<Person> set2 =new TreeSet<>();
set2.add(p1);
set2.add(p2);
set2.add(p3);
System.out.println(set2);

Comparator接⼝：⽐较器，实现定制⽐较。
compare(o1,o2)⽅法的返回值0，表示重复。
示例：

public class TestComparator {
public static void main(String[] args) {
//创建集合,并指定⽐较规则
TreeSet<Person> persons=new TreeSet<>(new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
int n1=o1.getAge()-o2.getAge();
int n2=o1.getName().compareTo(o2.getName());
return n1==0?n2:n1;
}
});
Person p1=new Person("xyz", 20);
Person p2=new Person("hello", 22);
Person p3=new Person("zhangsan", 25);
Person p4=new Person("lisi", 25);
persons.add(p1);
persons.add(p2);
persons.add(p3);
persons.add(p4);
System.out.println(persons.toString());
}
}

Map接⼝

map接⼝，也是⼀种容器。存储的数据是成对⼉出现。键(key)–>值(value)。
map存储的是键值对：key-value
注意点：
1.存储⽆序的键值对。
2.key必须是唯⼀的。⽽且和value是⼀⼀对应的。
常⽤⽅法：

⽅法名	描述
V put(K key,V value)	将对象存⼊到集合中，关联键值。key重复则覆盖原值。
Object get(Object key)	根据键获取对应的值。
Set keySet()	返回所有key。
Collection values()	返回包含所有值的Collection集合。
Set<Map.Entry<K,V>> entrySet()	键值匹配的Set集合。

Map实现类

HashMap
JDK1.2版本，线程不安全，运⾏效率快。
允许⽤null 作为key或是value。
存储结构：哈希表。
示例：

/*
put(key,value):往map集合中添加键值对
get(key):根据key，获取value;
remove(key):根据key,删除对应的键值对
keySet:key的集合
*/
Map<String,String> map = new HashMap<>();
String s1 = map.put("A", "aaa");//向Map集合中添加键值对
System.out.println("s1:"+s1);
System.out.println(map);
map.put("B","bbb");
map.put("C","ccc");
System.out.println(map);
String s2 = map.put("C", "vvvv");//如果有是重复的key,那么会覆盖原来的value,同时会返回被覆盖的value值
System.out.println("s2:"+s2);
System.out.println(map);
System.out.println("---------------");
String value = map.get("C");//获取指定的key 对应的value
System.out.println("value---->"+value);
System.out.println("------------");
System.out.println("size:"+map.size());
map.remove("C");
System.out.println(map);
//遍历map的key,然后根据key取相应的值,完成遍历
Set<String> keySet = map.keySet();
for(String key:keySet){
System.out.println(key+"------->"+map.get(key));
}

TreeMap
实现了SortedMap接⼝(Map的⼦接⼝)，可以对key⾃动排序，Key需实现Comparable接⼝。
示例：

Map<String,String> map = new TreeMap<>();
map.put("B","bbb");
map.put("A", "aaa");
map.put("C","ccc");
System.out.println(map);