java--集合的一些用法

最新推荐文章于 2022-11-20 14:02:46 发布

Franky_jie

最新推荐文章于 2022-11-20 14:02:46 发布

阅读量445

点赞数

分类专栏：学生文章标签： api

本文链接：https://blog.csdn.net/Franky_jie/article/details/55803817

版权

学生专栏收录该内容

16 篇文章 0 订阅

订阅专栏

本文详细介绍了Java集合框架的基本概念及核心组件，包括List、Set、Map等接口的区别与使用场景，以及ArrayList、LinkedList、HashSet、TreeSet等典型实现类的特点与应用场景。

摘要由CSDN通过智能技术生成

集合概念,下面是一些常用的集合特征
Collection 是所有集合的父类常用的子接口有 List Set Map下面是它们的一些显见区别
List —–允许有重复元素
Set—–不允许有重复元素
Map——-里面放的是一个个键值对（Key,Value）即一个entry对象
Collection接口

API: http://download.oracle.com/technetwork/java/javase/6/docs/zh/api/java/util/Collection.html

常用方法

List接口

API: http://www.apihome.cn/api/java/List.html

List接口简介:List接口继承自Collection接口，是单列集合的一个重要分支，习惯性地会将实现了List接口的对象称为List集合。在List集合中允许出现重复的元素，所有的元素是以一种线性的方式进行存储的，在程序中可以通过索引来访问集合中的指定元素。另外，List集合中还有一个特点就是元素的有序，即元素的存入顺序和取出顺序一致。

ArrayList类

API: http://download.oracle.com/technetwork/java/javase/6/docs/zh/api/java/util/ArrayList.html

/**
         * ArrayList集合（比较常用）
         */
        public static void test1(){
                 ArrayList<String> list = new ArrayList<String>();
                 list.add("lingdu");
                 list.add("小明");
                 list.add("小华");
                 //查看集合大小
                 System.out.println("集合大小：" + list.size());

                 System.out.println("\n修改***************************");
                 //修改
                 list.set(2, "小平");
                 System.out.println(list.get(2));

                 System.out.println("\n删除***************************");
                 //删除 （删除元素1 ->Lingdu,此时 元素2->小明  会向上移动一位变成元素1）
                 list.remove(0);
                 System.out.println(list.get(0));


                 System.out.println("\n遍历集合***************************");
                 //循环输出
                 Iterator<String> it = list.iterator();
                 while(it.hasNext()){
                         String str = (String)it.next();
                         System.out.println(str);
                 }

                 System.out.println("\n**********\n");

                 //集合与集合之间的操作
                 List<String> grilList = new ArrayList<String>();
                 grilList.add("小明");
                 grilList.add("小平");

                 //返回元素中是否包涵 Lingdu
                 System.out.println("list集合中是否包涵：lingdu -->" + list.contains("Lingdu"));
                 //如果列表包含指定的元素，则返回 true。
                 System.out.println("list集合中是否包涵：grilList集合的数据 -->" + list.contains(grilList));

                 //从列表中移除指定 collection 中包含的其所有元素
                 System.out.println("删除list集合中包涵grilList集合的所有元素：" + list.removeAll(grilList));

                 //创建迭代器
                 Iterator<String> it1 = list.iterator();

                 System.out.println("----------------");
                 while(it1.hasNext()){
                         String str1 = (String)it1.next();
                         System.out.println(str1);
                 }
                 //清空集合
                 list.clear();
                 System.out.println("清空之后集合的大小是：" + list.size());     
        }

LinkedList 类

API: http://download.oracle.com/technetwork/java/javase/6/docs/zh/api/java/util/LinkedList.html

/**
         * 使用LinkedList实现队列的效果
         */
        public static void test2(){
                 LinkedList<Person> list = new LinkedList<Person>();
                 Person p1 = new Person(18,"小明");
                 Person p2 = new Person(22,"小华");
                 Person p3 = new Person(21,"小王");
                 list.add(p1);
                 list.add(p2);
                 list.add(p3);
                 Person p = null;
                 while((p = (Person)list.pollLast()) != null){
                         System.out.println(p.name);
                 }
        }

/**
 * 测试类
 * @author LingDu
 */
class Person{
        int age;
        String name;
        public Person(int age,String name){
                 this.age = age;
                 this.name = name;
        }
        public Person(){}
}

Stack类

API: http://download.oracle.com/technetwork/java/javase/6/docs/zh/api/java/util/Stack.html

/**
         * 使用Stack堆栈实现后进先出的效果
         */
        public static void test3(){
                 Stack<Person> stack = new Stack<Person>();
                 Person p1 = new Person(18,"小明");
                 Person p2 = new Person(22,"小华");
                 Person p3 = new Person(21,"小王");
                 stack.add(p1);
                 stack.add(p2);
                 stack.add(p3);
                 Person p = null;
                 //如果集合不为空
                 while(stack.size() != 0){
                         p = stack.pop();
                         System.out.println(p.name);
                 }
        }

Set接口

API: http://download.oracle.com/technetwork/java/javase/6/docs/zh/api/java/util/Set.html

Set接口简介:

Set接口和List接口一样，同样继承自Collection接口，它与Collection接口中的方法基本一致，并没有对Collection接口进行功能上的扩充，只是比Collection接口更加严格了。与List接口不同的是，Set接口中的元素无序，并且都会与某种规则保证存入的元素不出现重复。

Set接口不能加入重复元素，但是可以排序

HashSet 类

API: http://download.oracle.com/technetwork/java/javase/6/docs/zh/api/java/util/HashSet.html

/**
         * HashSet 类
         * 特点：不能有重复
         */
        public static void test4(){
                 //使用HashSet测试，将相同的数据存入集合
                 HashSet<String> set = new HashSet<String>();
                 set.add("零度");
                 set.add("小明");
                 set.add("小华");
                 set.add("零度");
                 //输出HashSet集合长度，如果长度为3，说明已经集合中不能有重复的数据
                 System.out.println(set.size());

                 //使用ArrayList测试，将相同的数据存入集合
                 ArrayList<String> list = new ArrayList<String>();
                 list.add("零度");
                 list.add("小明");
                 list.add("小华");
                 list.add("零度");
                 //输出ArrayList集合长度，该集合可以存入重复的数据
                 System.out.println(list.size());

        }

TreeSet类

API: http://download.oracle.com/technetwork/java/javase/6/docs/zh/api/java/util/TreeSet.html

对数字进行排序

/**
         * treeMap可以自然排序
* 对数字进行排序
         */
        public static void test9(){
                 TreeMap<String, String> map = new TreeMap<String, String>();
                 map.put("0000001", "lingdu");
                 map.put("0000002", "xiaorui");
                 map.put("0000003", "jony");
                 Set<String> set = map.keySet();
                 for (Iterator<String> iterator = set.iterator(); iterator.hasNext();) {
                         String string = (String) iterator.next();
                         System.out.println(string);
                 }
        }

对字母进行排序


/**
         * TreeSet
         * 对字母进行排序
         */
        public static void test6(){
                 TreeSet<String> set = new TreeSet<String>();
                 set.add("w");
                 set.add("f");
                 set.add("g");
                set.add("z");
                 for (Iterator<String> iterator = set.iterator(); iterator.hasNext();) {
                         String i = (String) iterator.next();
                         System.out.println(i);
                 }
        }

对汉字进行排序

/**
         * TreeSet
         * 对汉字进行排序
         */
        public static void test6(){
                 TreeSet<String> set = new TreeSet<String>();
                 set.add("玛");
                 set.add("王");
                 set.add("玝");
                 set.add("玜");
                 for (Iterator<String> iterator = set.iterator(); iterator.hasNext();) {
                         String i = (String) iterator.next();
                         System.out.println(i);
                 }
        }

对自定义对象的排序

/**
         * 使用TreeSet类比较自定义对象
         * 有几个朋友，按朋友年龄排序
         */
        public static void test7(){
                 //实例化TreeSet类并且实现Comparator接口，重写compare方法
                 TreeSet<Friend> set = new TreeSet<Friend>(new  Comparator<Friend>() {
                         int returnNum = 0;
                         /**
                          * 通过年龄进行排序
                          */
                         @Override
                         public int compare(Friend o1, Friend o2) {
                                  int o1Age = o1.age;
                                  int o2Age = o2.age;
                                  if(o1Age > o2Age){
                                          returnNum = 1;
                                  }else if(o1Age == o2Age){
                                          returnNum = 0;
                                  }else if(o1Age < o2Age){
                                          returnNum = -1;
                                  }
                                 return returnNum;
                         }
                 });
                 set.add(new Friend("lingdu",22,0));
                 set.add(new Friend("xiaohua",25,1));
                 set.add(new Friend("xiaoping",18,2));
                 set.add(new Friend("xiaowang",20,3));
                 for (Iterator<Friend> iterator = set.iterator(); iterator.hasNext();) {
                         Friend friend = (Friend) iterator.next();
                         System.out.println(friend.name);
                 }
        }

Map接口

API: http://download.oracle.com/technetwork/java/javase/6/docs/zh/api/java/util/Map.html

Map接口简介：

System这个类可以得到系统的环境变量也可以得到系统的属性返回的是map集合即一个个的键值对（getProperties() getEnv()这两个方法）Map接口储存一组成对的键-值对象，提供key（键）到value（值）的映射，Map中的key不要求有序，不允许重复。value同样不要求有序，但可以重复。最常见的Map实现类是HashMap，他的储存方式是哈希表，优点是查询指定元素效率高。
Map接口提供了将键映射到集合的对象,一个映射不能包含重复的键.
每个键最多只能映射到一个值.Map接口中同样提供了集合的常用方法,如clear()方法,isEmpty()方法,Size()方法等.

HashMap< K,V>类

API: http://download.oracle.com/technetwork/java/javase/6/docs/zh/api/java/util/HashMap.html

/**
         *  hashMap的用法
         *  K - 此映射所维护的键的类型
         *  V - 所映射值的类型
         */
        public static void test8(){
                 HashMap<String, String> map = new HashMap<String, String>();
                 map.put("lingdu", "123");
                 map.put("shaojie", "888");
                 //String str = map.get("lingdu");
                 //System.out.println(str);

                 //遍历这个map的三种方式：

                 System.out.println("\n1：使用keySet()方法拿到key值-----------------");

                 //先用第一个方法：KeySet()
                 Set<String> keySet = map.keySet();
                 for (Iterator<String> iterator = keySet.iterator(); iterator.hasNext();) {
                         String key = (String) iterator.next();
                         System.out.println(map.get(key));
                 }

                 System.out.println("\n2：使用values()方法拿到value值-----------------");

                 //用第二种方法：获取values()
                 Collection<String> coll = map.values();
                 for (Iterator<String> iterator = coll.iterator(); iterator.hasNext();) {
                         String values = (String) iterator.next();
                         System.out.println(values);
                 }

                 System.out.println("\n2：使用entrySet()方法拿到所有的key值跟value值-----------------");
                 //第三那种方法：同时把key和value都取出来
                 //一个map里包含了多个entry对象，一个entry又包含了一个key和一个value对象
                 Set<Entry<String, String>> set2 =map.entrySet();
                 for (Iterator<Entry<String, String>> iterator = set2.iterator(); iterator.hasNext();) {
                         Entry<String, String> entry = (Entry<String, String>) iterator.next();
                         System.out.println(entry.getKey() + "=" + entry.getValue());
                 }
        }

TreeMap< K,V>类

API: http://download.oracle.com/technetwork/java/javase/6/docs/zh/api/java/util/TreeMap.html

/**
         * TreeMap可以自然排序
         */
        public static void test9(){
                 TreeMap<String, String> map = new TreeMap<String, String>();
                 map.put("0000002", "lingdu");
                 map.put("0000001", "xiaorui");
                 map.put("0000003", "jony");
                 //对key值进行排序
                 Set<String> set = map.keySet();
                 for (Iterator<String> iterator = set.iterator(); iterator.hasNext();) {
                         String string = (String) iterator.next();
                         System.out.println(string + "------>" + map.get(string));
                 }
        }

对自定义对象进行排序



/**
         * 自定义对象排序
         */
        public static void test10(){
                 //实现Comparator<E>接口，重写compare方法
                 TreeMap<String, Friend> map = new TreeMap<String, Friend>(new Comparator<String>() {

                         @Override
                         public int compare(String o1, String o2) {
                                  //compareTo()方法  ---比较两个值，如果前者大于后者，返回1，等于返回0，小于返回-1
                                  return o1.compareTo(o2);
                         }
                 });
                 map.put("4127000002", new Friend("lingdd",22,0));
                 map.put("4127000001", new Friend("xiaohua",25,1));
                 map.put("4127000003", new Friend("xiaoming",21,-1));
                 //拿到所有的values值
                 Collection<Friend> coll = map.values();
                 //遍历集合
                 for (Iterator<Friend> iterator = coll.iterator(); iterator.hasNext();) {
                         Friend friend = (Friend) iterator.next();
                         System.out.println(friend.name);
                 }
        }