1.概念
- java集合存放于包java.util包中，是一个用来存放对象的容器
- 只能存放对象，例如：存放int是转换成Integer对象
- 集合存放的是多个对象的引用，对象本身还是放在堆内存中
- 集合可以存放不同类型，不限数量的数据类型
2 HashSet(无序，不可重复)
- HashSet是set接口的典型实现，大多数时候使用Set集合时都使用这个实现类。我们大多数时候说的set集合指的都是HashSet集合
- HashSet按Hash算法来存储集合中的元素，因此具有很好的存取和查找功能
- Hash具有以下特点：不能保证元素的排列顺序，不可重复，HashSet不是线程安全的，集合元素可以使null
- 当向HashSet集合中存入一个元素时，HashSet会调用该对象的hashCode()方法来得到该对象的hashcode值，然后根据hashCode值决定该对象在HashSet中的存储位置
- 如果两个元素的equals()方法返回true，但它们的hashCode()返回值不相等，hashSet将会把它们存储在不同的位置，但依然可以添加成功
2.1 代码如下：
package demo;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class Test2 {
public static void main(String[] args) {
Set set=new HashSet();
//Set<Object> set=new HashSet<Object>();//与上面的等价
set.add(1);
set.add("a");//添加对象到集合
System.out.println("添加对象到集合:"+set);//添加对象到集合:[1, a]
set.remove(1);//移除对象
System.out.println("移除对象:"+set);//移除对象:[a]
System.out.println("判断是否包含元素1:"+set.contains(1));//判断是否包含元素1:false
System.out.println("判断是否包含元素a:"+set.contains("a"));//判断是否包含元素a:true
set.clear();//清空集合
System.out.println("清空集合:"+set);//清空集合:[]
set.add("a");
set.add("b");
set.add("c");
set.add("d");
//set集合存的值是不重复的
set.add(1);
set.add(true);
set.add(null);
System.out.println(set);//[null, a, 1, b, c, d, true]
//迭代器遍历集合
System.out.println("迭代器遍历集合");
Iterator it=set.iterator();
while(it.hasNext()) {
System.out.print(it.next()+" ");//null a 1 b c d true
}
//for Each迭代集合
System.out.println();
System.out.println("for Each迭代集合");
for(Object obj:set) {//这个意思是说把set的每一个值取出来赋值给obj,直到循环set的所有值
System.out.print(obj+" ");//null a 1 b c d true
}
System.out.println();
System.out.println(set.size());//获取集合的元素个数:7
//如果想要让集合只能存同样类型的对象，怎么做
//使用泛型
Set<String> set1=new HashSet<String>();//比如指定String为集合的泛型，那么这个集合不能存String类型之外的数据
set1.add("abc");
//set1.add(1);这样是不行的
}
}
3.TreeSet(有序，不可重复)
- TreeSet可以确保集合元素处于排序状态，TreeSet支持两种排序方法：自然排序和定制排序
3.1 代码如下
package demo;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
public class Test3 {
public static void main(String[] args) {
// TODO 自动生成的方法存根
Set<Integer> set=new TreeSet<Integer>();//TreeSet的自然排序
set.add(5);
set.add(2);
set.add(4);
set.add(3);
set.add(1);
System.out.println("添加对象到集合:"+set);//添加对象到集合:[1, 2, 3, 4, 5]
set.remove(1);//移除对象
System.out.println("移除对象:"+set);//移除对象:[2, 3, 4, 5]
System.out.println("判断是否包含元素1:"+set.contains(1));//判断是否包含元素1:false
//迭代器遍历集合
System.out.println("迭代器遍历集合");
Iterator<Integer> it=set.iterator();
while(it.hasNext()) {
System.out.print(it.next()+" ");//2 3 4 5
}
//for Each迭代集合
System.out.println();
System.out.println("for Each迭代集合");
for(Integer i:set) {//这个意思是说把set的每一个值取出来赋值给obj,直到循环set的所有值
System.out.print(i+" ");//2 3 4 5
}
System.out.println();
System.out.println(set.size());//获取集合的元素个数:4
set.clear();//清空集合
System.out.println("清空集合:"+set);//清空集合:[]
Person p1=new Person("zhangsan",17);
Person p2=new Person("lisi",23);
Person p3=new Person("wangwu",20);
Person p4=new Person("zhaoliu",29);
Set<Person> set1=new TreeSet<Person>(new Person());//TreeSet的定制排序
set1.add(p2);
set1.add(p4);
set1.add(p3);
set1.add(p1);
System.out.println("for Each迭代集合");
for(Person p:set1) {//这个意思是说把set的每一个值取出来赋值给obj,直到循环set的所有值
System.out.println(p.name+" "+p.age+" ");//zhangsan 17 wangwu 20 lisi 23 zhaoliu 29
}
}
}
//TreeSet定制排序，需要实现Comparator接口
class Person implements Comparator<Person>{ //把Person对象存到TreeSet中并按照年龄排序
int age;
String name;
public Person() {
}
public Person(String name,int age) {
this.name=name;
this.age=age;
}
@Override
public int compare(Person arg0, Person arg1) {
// TODO 自动生成的方法存根
if(arg0.age>arg1.age) {
return 1;
}else if(arg0.age<arg1.age) {
return -1;
}else {
return 1;
}
}
}
4.List(有序，可重复,有索引)
4.1 ArrayList
package demo;
import java.util.ArrayList;
public class List {
public static void main(String[] args) {
// TODO 自动生成的方法存根
ArrayList<String> list=new ArrayList<String>();
list.add("b");//第一个，索引下标0
list.add("d");//第二个，索引下标1
list.add("a");//允许使用重复元素
list.add("e");
list.add("c");
list.add("a");
System.out.println("按默认方式存入数据"+list);//按默认方式存入数据[b, d, a, e, c, a]
System.out.println(list.get(2));//通过索引来访问指定位置的集合元素:a
list.add(1,"f");
System.out.println("在指定下标的位置插入数据"+list);//在指定下标的位置插入数据[b, f, d, a, e, c, a]
ArrayList<String> list1=new ArrayList<String>();
list1.add("123");
list1.add("456");
list.addAll(2, list1);//在指定元素位置插入集合
System.out.println("按在指定元素位置存入集合数据"+list);//按在指定元素位置存入集合数据[b, f, 123, 456, d, a, e, c, a]
System.out.println(list.indexOf("a"));//获取指定元素在集合第一次出现的索引下标:5
System.out.println(list.lastIndexOf("a"));//获取指定元素在集合最后一次出现的索引下标:8
list.remove(2);//根据指定索引下标移除元素
System.out.println("移除对象:"+list);//移除对象:[b, f, 456, d, a, e, c, a]
list.set(1,"ff");//修改指定下标的值
System.out.println("修改指定下标之后的集合"+list);//修改指定下标之后的集合[b, ff, 456, d, a, e, c, a]
@SuppressWarnings("unused")
//根据索引的起始位置来截取一段元素形成一个新集合，元素的索引截取时包含开始，不包含结尾
java.util.List<String> sublist=list.subList(2, 4);
System.out.println("截取的数组:"+sublist);//截取的数组:[456, d]
System.out.println(list.size());//获取集合的元素个数:8
}
}
5.Map(具有映射关系)
- Map有两组值，一个是key，一个是value，类型不限，key不允许有重复值，key与value存在单向1对1关系
5.1 HashMap与TreeMap
package demo;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;
public class Map {
public static void main(String[] args) {
//前面试接口，后面是实现类
//Map<String,Integer> map=new HashMap;
HashMap<String,Integer> map=new HashMap<String,Integer>();
map.put("b",1);
map.put("c",2);
map.put("a",2);
System.out.println("按默认方式存入数据："+map);//按默认方式存入数据：{a=2, b=1, c=2}
System.out.println("根据key取值："+map.get("b"));//根据key取值：1
map.remove("c");
System.out.println("根据key移除键值对:"+map);//根据key移除键值对:{a=2, b=1}
System.out.println("获取集合的元素个数:"+map.size());//获取集合的元素个数:2
System.out.println("判断当前的集合是否存在指定的key:"+map.containsKey("b"));//判断当前的集合是否存在指定的key:true
System.out.println("判断当前的集合是否存在指定的value:"+map.containsValue(1));//判断当前的集合是否存在指定的value:true
System.out.println("获取map集合的key的集合："+map.keySet());//获取map集合的key的集合：[a, b]
System.out.println("获取map集合的所有value值："+map.values());//获取map集合的所有value值：[2, 1]
Set<String> keys=map.keySet();
//for Each迭代集合,通过map.keySet()遍历map集合
System.out.println();
System.out.println("for Each迭代集合,通过map.keySet()遍历map集合");
for(String key:keys) {//这个意思是说把set的每一个值取出来赋值给key,直到循环keys的所有值
System.out.println("key:"+key+",value:"+map.get(key));key:a,value:2 key:b,value:1
}
//for Each迭代集合, 通过map.entrySet()遍历map集合
Set<Entry<String,Integer>> entrys=map.entrySet();
System.out.println();
System.out.println("for Each迭代集合,通过map.entrySet()遍历map集合");
for(Entry<String,Integer> en:entrys) {//这个意思是说把set的每一个值取出来赋值给key,直到循环keys的所有值
System.out.println("key:"+en.getKey()+",value:"+en.getValue());//key:a,value:2 key:b,value:1
}
map.clear();//清空集合
System.out.println("清空数据："+map);//清空数据：{}
//TreeMap自然排序是遵循字典排序，自定义排序与HashSet相类似
TreeMap<Integer,String> map1=new TreeMap<Integer,String>();
map1.put(4, "a");
map1.put(2, "a");
map1.put(3, "a");
map1.put(1, "a");
System.out.println("TreeMap："+map1);//TreeMap：{1=a, 2=a, 3=a, 4=a}
TreeMap<String,String> map2=new TreeMap<String,String>();
map2.put("b", "b");
map2.put("c", "c");
map2.put("d", "d");
map2.put("a", "a");
map2.put("ab", "ab");
System.out.println("TreeMap："+map2);//TreeMap：{a=a, ab=ab, b=b, c=c, d=d}
}
}
6.collection
package demo;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class Collectiontest {
public static void main(String[] args) {
// TODO 自动生成的方法存根
ArrayList<String> list=new ArrayList<String>();
list.add("b");//第一个，索引下标0
list.add("cd");//第二个，索引下标1
list.add("ca");//允许使用重复元素
list.add("a");
list.add("1");
System.out.println("按默认方式存入数据:"+list);//按默认方式存入数据:[b, cd, ca, a, 1]
Collections.reverse(list);
System.out.println("反转List中元素的顺序:"+list);//反转List中元素的顺序:[1, a, ca, cd, b]
Collections.shuffle(list);
System.out.println("对List中元素进行随机排序:"+list);//对List中元素进行随机排序:[a, 1, ca, cd, b]
Collections.sort(list);
System.out.println("List集合字典升序排序:"+list);//List集合字典升序排序:[1, a, b, ca, cd]
System.out.println("输出最大："+Collections.max(list));//输出最大：cd
System.out.println("输出最小："+Collections.min(list));//输出最小：1
Collections.swap(list, 0, 4);//
System.out.println("将指定list集合中的i处元素和j处元素进行交换后:"+list);//将指定list集合中的i处元素和j处元素进行交换后:[cd, a, b, ca, 1]
Student s1=new Student(14,"zhangsan");
Student s2=new Student(12,"lisi");
Student s3=new Student(13,"wangwu");
Student s4=new Student(11,"suiliu");
ArrayList<Student> stus=new ArrayList<Student>();//自定义排序
stus.add(s1);
stus.add(s2);
stus.add(s3);
stus.add(s4);
for(Student stu:stus) {
System.out.print(stu.name+","+stu.age+" ");//zhangsan,14 lisi,12 wangwu,13 suiliu,11
}
Collections.sort(stus,new Student());//按照指定方法排序
System.out.println();
for(Student stu:stus) {
System.out.print(stu.name+","+stu.age+" ");//suiliu,11 lisi,12 wangwu,13 zhangsan,14
}
Student ss=Collections.min(stus,new Student());
System.out.println(ss.name+"输出最大："+ss.age);//suiliu输出最大：11
}
}
class Student implements Comparator<Student>{
int age;
String name;
public Student() {
}
public Student(int age,String name) {
this.name=name;
this.age=age;
}
@Override
public int compare(Student arg0, Student arg1) {//根据年龄升序排列
// TODO 自动生成的方法存根
if(arg0.age>arg1.age) {
return 1;
}else if(arg0.age<arg1.age) {
return -1;
}else {
return 1;
}
}
}