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

版权声明:本文为dongxuelove原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://www.cnblogs.com/dongxuelove/p/13029626.html