Collection接口中定义的方法
Collection接口中定义的方法是所有的集合中都具有的基本的方法.
public static void main(String[] args) {
/*
* 集合中默认可以存储任意数据类型,建议使用泛型,存储同一种类型的数据
*/
Collection<String> c = new ArrayList<String>();
c.add("abc");
c.add("ab");
c.add("c");
c.add("d");
//c.clear();
//System.out.println(c.remove("f"));//删除指定的元素,有返回true,否则返回false
//System.out.println(c.contains("a"));
//System.out.println(c.isEmpty());
//有条件的删除
/* c.removeIf(new Predicate<String>() {
public boolean test(String t) {
return t.startsWith("a");//删除的过滤条件
};
});*/
//流的方式遍历集合
//c.stream().forEach((a)->System.out.println(a));
System.out.println(c);
}
public static void main(String[] args) {
/*
* 集合中默认可以存储任意数据类型,建议使用泛型,存储同一种类型的数据
*/
Collection<String> c = new ArrayList<String>();
c.add("abc");
c.add("ab");
c.add("c");
c.add("d");
//集合转 数组
Object [] obj = c.toArray();
String [] str = c.toArray(new String[c.size()]);
System.out.println(c);
//数组转集合
/*int [] a = {1,2,3,4};
Collection c1 = Arrays.asList(a);
System.out.println(c1);*/
test(1,2,3,4);
}
/*
* int...a 可变长度的参数,本质是一个数组
* 一个参数列表中只能有一个可变长度的参数,并且只能放在参数列表的末尾
*/
public static void test(int a,int...b){
System.out.println(a);
System.out.println(Arrays.toString(b));
}
List
可以存储重复元素
ArrayList
数组实现 查询快,增删慢(在中间)
LinkedList
链表实现 查询慢,增删快
Vector
数组实现,线程安全的
集合的迭代
Stream.forEach(lambda表达式)
for 循环
增强for
迭代器
iterator() 返回一个迭代器 计数器
listIterator()
ArrayList
实例1:
package com.ff.javaCollection.day2;
import java.util.ArrayList;
public class Demo1 {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("a");
arrayList.add("b");
arrayList.add("c");
arrayList.add("a");
arrayList.add("a");
arrayList.add("a");
arrayList.add("d");
//遍历方式1:List接口实现类的遍历,stream流
arrayList.stream().forEach((a) -> System.out.print(a));
System.out.println();
//遍历方式2:for循环
//要从集合中删除元素时要注意,删除后会出现元素下标和集合中大的内容不对应的情况,因此要i--,返回上一个元素在检验一次
for (int i = 0; i < arrayList.size(); i++) {
if (arrayList.get(i).equals("a")) {
arrayList.remove(i);
i--;
}
}
System.out.println(arrayList);
//遍历方式3:增强for循环,理论上不允许删除集合中的元素
//如果删除元素,会出现异常:java.util.ConcurrentModificationException,若要删除,只允许一次删除一个,删除完后用break终止循环
for (String temp : arrayList) {
if (temp.equals("a")) {
arrayList.remove(temp);
break;
}
}
System.out.println(arrayList);
}
}
运行结果:
实例2:
package com.ff.javaCollection.day2;
import java.util.ArrayList;
import java.util.Iterator;
public class IteratorDemo1 {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("a");
arrayList.add("b");
arrayList.add("a");
arrayList.add("c");
arrayList.add("d");
Iterator it = arrayList.iterator();
// System.out.println(it);//java.util.ArrayList$Itr@15db9742
/*迭代器1 Iterator的遍历
hasNext()判断集合中还有没有元素
remove()删除元素,删除后里面的游标(指针,计数器)会回退一下
*/
while (it.hasNext()) {
Object s = it.next();
//去除重复元素“a"
if (s.equals("a")) {
it.remove();//使用迭代器中提供的remove()方法
}
}
System.out.println(arrayList);
}
}
运行结果:
实例:3:
package com.ff.javaCollection.day2;
import java.util.ArrayList;
import java.util.ListIterator;
/*迭代器2 ListIterator()
适用于List接口实现类
遍历时还可以添加元素,设置替换元素,nextIndex()元素位置
*/
public class IteratorDemo2 {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("a");
arrayList.add("b");
arrayList.add("a");
arrayList.add("c");
arrayList.add("d");
/*
//从前向后遍历元素
ListIterator listIterator = arrayList.listIterator();
while (listIterator.hasNext()){
//System.out.println(listIterator.next());
//System.out.println(listIterator.nextIndex());//依次获取遍历时候的下标
//System.out.println(listIterator.next()+":"+listIterator.nextIndex());
System.out.println(listIterator.next());
// listIterator.add("a");//在每个元素后加“a”
//listIterator.set("s");//将所有元素设置为“s”
listIterator.remove();//将全部的元素移除
}*/
//从后向前遍历元素
ListIterator listIterator = arrayList.listIterator(arrayList.size());
System.out.println(listIterator.hasPrevious());
while (listIterator.hasPrevious()) {
System.out.println(listIterator.previous());
}
System.out.println(arrayList);
}
}
运行结果:
linkedList
实例:
package com.ff.javaCollection.day2;
import java.util.LinkedList;
public class LinkedListDemo {
public static void main(String[] args) {
LinkedList<String> linkedList = new LinkedList<>();
//linkedList中提供了许多关于链表头尾的操作方法,这些方法用于模拟对列结构,栈操作等
linkedList.addLast("a");
linkedList.addLast("b");
linkedList.addLast("c");
linkedList.addLast("d");
linkedList.addLast("e");
// linkedList.clear();
System.out.println(linkedList.pollFirst());//检索并删除此列中的第一个元素并输出。若此列为空,则返回null
System.out.println(linkedList);
System.out.println(linkedList.peekFirst());//检索但不删除此列的第一个元素,并输出。若为空,则返回null
System.out.println(linkedList.getFirst());//得到第一个元素
System.out.println(linkedList.removeFirst());//删除并返回第一个元素
System.out.println(linkedList);
linkedList.addFirst("1");
linkedList.offerFirst("1");
linkedList.offerLast("x");
}
}
运行结果:
Vactor
实例:
package com.ff.colletion.day3;
/*
* Vactor
* 1.底层也是数组实现的
* 2.在创建Vactor对象时就已经创建了底层的存储数组,默认长度为10
* 3.Vator中所有方法都是线程安全的
*/
import java.util.Vector;
public class VactorDemo {
public static void main(String[] args) {
Vector v = new Vector();
v.add("a");
v.add("a");
v.add("a");
System.out.println(v);
}
}
运行结果:
Set
Set:不能存储重复元素
HashSet
实例1:
package com.ff.colletion.day3;
/*
* set 不可以存放重复元素
* HashSet 不可以存放重复元素,无序存储。(不是按照添加顺序排列)
*/
import java.util.HashSet;
public class HashSetDemo {
public static void main(String[] args) {
HashSet<String> hs = new HashSet();
hs.add("a");
hs.add("a");
hs.add("c");
hs.add("d");
hs.add("g");
hs.add("f");
hs.add("s");
hs.add("x");
System.out.println(hs);
/*
* 1.哈希结构的底层是如何实现的 2.HashSet是如何去除重复元素的
*/
}
}
运行结果:
实例2:
package com.ff.colletion.day3;
import java.util.HashSet;
public class HashSetDemo2 {
/*
Set 不能存储重复元素
HashSet 无序存储(不是按照添加顺序排列)
*/
public static void main(String [] args) {
HashSet <String> set = new HashSet <String>();
set.add("a");
set.add("x");
set.add("s");
set.add("p");
set.add("通话");
set.add("重地");
set.add("b");
System.out.println(set);
/*
1.哈希结构的底层是如何存储数据
哈希表 :哈希表本质也是数组
2.HashSet是如何去除重复元素的
先用元素的哈希值比较(快) 但是内容不同,hash值可能相同
hash相同时,再使用equals()方法判断内容是否相等 (安全可靠,但是效率低)
双保险:保证效率,又保证了安全
*/
}
}
运行结果:
实例3:创建一个学生类实现Comparable接口
package com.ff.javaCollection.day3;
import java.util.Objects;
public class Student implements Comparable<Student> {
private int num;
private String name;
@Override
public String toString() {
return "Student{" +
"num=" + num +
", name='" + name + '\'' +
'}';
}
public Student(int num, String name) {
this.num = num;
this.name = name;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return num == student.num &&
Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(num, name);
}
@Override
public int compareTo(Student o) {
int result = this.num - o.num;
return result;
}
}
实例:
package com.ff.javaCollection.day3;
/*
HashSet是如何判断内容重复的
1.每次添加元素时会用内容的hash值来判断是否相等,但hash值这种方法不安全,可能会出现内容不同但hash值相同(但用这种方法速度快),
2.出现内容不同,hash值相同(又称为hash碰撞,hash冲突)时,使用equals()方法比较,比较的是内容是否相等(速度慢但是安全)
hash值怎么来?
调用hashCode()方法,两种情况:1.类中已经重写了hashCode(),例如String类,根据内容来计算hash值2.类中没有重写hashCode(),调用Object类中的hashCode()
自己类中重写hashCode(),根据内容计算hash值,当hash值相同时调用equals()判断内容是否相等
*/
import java.util.HashSet;
/*
需要重写toString()方法,否则输出时默认调用Object类中的toString(),我们看不懂的东西
当没有重写hashSet()和equals()方法时候,相同的元素也可以加入
输出结果为:
[Student{num=3, name='重地'}, Student{num=2, name='通话'}, Student{num=1, name='wang'}, Student{num=1, name='wang'}]
当重写过hashSet()和equals()方法时候,会调用自己类中的hashSet()和equals()方法,则相同的元素不可以加入
输出结果为:
[Student{num=2, name='通话'}, Student{num=3, name='重地'}, Student{num=1, name='wang'}]
*/
public class HashSetDemo {
public static void main(String[] args) {
HashSet hashSet = new HashSet();
Student student1 = new Student(1,"wang");
Student student2 = new Student(2,"通话");
Student student3 = new Student(3,"重地");
Student student4 = new Student(1,"wang");
hashSet.add(student1);
hashSet.add(student2);
hashSet.add(student3);
hashSet.add(student4);
System.out.println(hashSet);
}
}
运行结果:
TreeSet
实例1:
package com.ff.javaCollection.day3;
import java.util.TreeSet;
/*
set不可以存储重复元素
TreeSet可以按照元素的自然顺序排列,底层是红黑树
在String中 compareTo()方法会在add()方法中调用
*/
public class TreeSetDemo {
public static void main(String[] args) {
TreeSet<String> treeSet = new TreeSet<>();
treeSet.add("1");
treeSet.add("3");
treeSet.add("2");
treeSet.add("1");
treeSet.add("4");
System.out.println(treeSet);
}
}
运行结果:
实例2:
package com.ff.javaCollection.day3;
/*
在Student类中compareTo()不会在add()方法中进行调用
直接运行会出现以下错误java.lang.ClassCastException: com.ff.javaCollection.day3.Student cannot be cast to java.lang.Comparable
需要在student中重写compareTo()方法
*/
import java.util.TreeSet;
public class TreeSetDemo2 {
public static void main(String[] args) {
TreeSet<Student> treeSet = new TreeSet<>();
Student student1 = new Student(1,"wang");
Student student2 = new Student(2,"通话");
Student student3 = new Student(3,"重地");
Student student4 = new Student(1,"wang");
treeSet.add(student1);
treeSet.add(student2);
treeSet.add(student3);
treeSet.add(student4);
System.out.println(treeSet);
}
}
运行结果:
实例3:
package com.ff.javaCollection.day3;
/*
TreeSet没有索引的下标,所以不可以使用for循环遍历
1.stream()
2.forEach()
3. Iterator()
*/
import java.util.Iterator;
import java.util.TreeSet;
public class SetBianLi {
public static void main(String[] args) {
TreeSet<String> treeSet = new TreeSet<>();
treeSet.add("1");
treeSet.add("3");
treeSet.add("2");
treeSet.add("1");
treeSet.add("4");
//treeSet.stream().forEach((a)-> System.out.println(a));
/*for (String t:treeSet) {
System.out.println(t);
}*/
Iterator<String> iterator = treeSet.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}
运行结果:
Map
Map 集合:键值对存储,键不可以重复,值可以重复
TreeMap
实例:
package com.ff.javaCollection.day4;
/*
TreeMap
键值对存储,键不可以重复
可以根据键的自然顺序排序,指定的键的类型的类必须实现Comparable接口,在排序中使用
*/
import java.util.TreeMap;
public class TreeMapDemo {
public static void main(String[] args) {
TreeMap<String,String> treeMap = new TreeMap<>();
treeMap.put("3","1");
treeMap.put("3","2");
treeMap.put("1","1");
treeMap.put("5","5");
treeMap.put("2","2");
treeMap.put("0","0");
System.out.println(treeMap);
}
}
运行结果:
HashMap
实例:
package com.ff.javaCollection.day4;
/*
Map 集合
键值对存储,键不可以重复,值可以重复
HashMap
键是无序的
如果有重复的值,后面的值会把前面的值覆盖
可以存储一个为空的键
*/
import java.util.HashMap;
public class HashMapDemo {
public static void main(String[] args) {
HashMap<Integer,String> hashMap = new HashMap<>();
hashMap.put(2,"13");
hashMap.put(2,"12");
hashMap.put(1,"1");
hashMap.put(4,"4");
hashMap.put(3,"3");
hashMap.put(null,"3");
hashMap.put(null,"30");
System.out.println(hashMap);
hashMap.remove(2);//删除键为2的
//hashMap.clear();//清楚集合中的所有元素
System.out.println(hashMap.containsKey(5));//若包含键为5的就返回true
System.out.println(hashMap.containsValue(3));//若包含值为3 的就返回true
System.out.println(hashMap.isEmpty());//判断是否为空
System.out.println(hashMap.size());//获取hashMap中有几组键值对
System.out.println(hashMap.get(4));//得到键所对应的值并返回
}
}
运行结果:
Hashtable
实例:
package com.ff.javaCollection.day4;
/*
Hashtable
无序的
容量为11
线程安全
*/
import java.util.Hashtable;
public class HashTableDemo {
public static void main(String[] args) {
Hashtable<String, String> hashTable = new Hashtable<>();
hashTable.put("d", "1");
hashTable.put("a", "2");
hashTable.put("c", "3");
hashTable.put("b", "4");
// hashTable.put(null,"4"); 不允许存放为null的键,否则会出异常 java.lang.NullPointerException
System.out.println(hashTable);
}
}
运行结果:
实例:
package com.ff.javaCollection.day4;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/*
Map集合的遍历
1.流的方式 2.forEach 3.entrySet()+forEach 4. entrySet()+Iterator
*/
public class MapBianLi {
public static void main(String[] args) {
HashMap<String, String> hashMap = new HashMap<>();
hashMap.put("5", "5");
hashMap.put("2", "2");
hashMap.put("3", "3");
hashMap.put("6", "6");
hashMap.put("1", "1");
//hashMap.forEach((k,v)-> System.out.println(k+":"+v));
/* //keyset()先获取到hashMap中的所有键,存储到集合set中,再对set集合进行遍历,通过get()方法得到对应的value。遍历效率低,所以很少使用
Set<String> keyset = hashMap.keySet();
for (String key: keyset) {
System.out.println(key+":"+hashMap.get(key));
}*/
/* //entrySet()将hashmap集合中的键值对封装到一个Entry对象中
Set<Map.Entry<String,String>> entrySet = hashMap.entrySet();
for (Map.Entry<String,String> entry : entrySet) {
System.out.println(entry.getKey()+":"+entry.getValue());
}*/
Set<Map.Entry<String, String>> entrySet = hashMap.entrySet();
Iterator<Map.Entry<String, String>> it = entrySet.iterator();
while (it.hasNext()) {
Map.Entry<String, String> entry = it.next();
System.out.println(entry.getKey() + ":" + entry.getValue());
}
}
}
运行结果:
Collections
Collections中定义的方法
实例:
package com.ff.javaCollection.day4;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
public class CollectionsDemo {
public static void main(String[] args) {
/* ArrayList arrayList = new ArrayList();
arrayList.add("a");
arrayList.add("b");
arrayList.add("c");
arrayList.add("d");
Collections.addAll(arrayList,"e","f","g");//添加元素
System.out.println(arrayList);
Collections.sort(arrayList);//排序
System.out.println(Collections.binarySearch(arrayList,"f"));//使用二分法查找元素(前提,集合中元素必须有序)
*/
ArrayList<String> arrayList1 = new ArrayList();
arrayList1.add("a");
arrayList1.add("b");
arrayList1.add("c");
arrayList1.add("d");
ArrayList<String> arrayList2 = new ArrayList();
arrayList2.add("e");
arrayList2.add("f");
arrayList2.add("g");
Collections.copy(arrayList1, arrayList2);//此方法沒有返回值,不可以输出。dest集合中的size不可以小于src集合中的size
System.out.println(arrayList1);
//List<Object> list = Collections.emptyList();//此方法中不可以加入元素
//list.add("x");
Collections.fill(arrayList1, "s");//用s填充arrayList1中的所有元素
System.out.println(arrayList1);
System.out.println(Collections.max(arrayList2));//找出arrayList2中最大的元素
Collections.replaceAll(arrayList2, "e", "E");//在arrayList2中用E代替e
System.out.println(arrayList2);
Collections.reverse(arrayList2);//逆序输出arrayList2
System.out.println(arrayList2);
Collections.swap(arrayList2, 1, 2);//交换顺序
System.out.println(arrayList2);
}
}
运行结果: