疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

Java集合类的整理


 

JAVA集合概述
     集合类主要负责保存、盛装其他数据,因此集合类也被称为容器类。所有的集合类的都在java.util包下。
 
       集合类和数组不一样,数组元素既可以是基本类型的值,也可以是对象(实际上保存的是对象的引用变量);而集合只能保存对象。
 
       Java的集合类主要由Collections和Map,Collections和Map是Java集合框架的根接口,Java中集合的继承关系如下:
 
 
 
Collection集合列的继承关系
 
 
 
Map接口的继承关系
 
2、Collection接口和Iterator接口
    一、Collection接口
           collection接口是List、set和Queue接口的父接口,该接口里定义的方法可用于操作Set集合。并且所有的Collection实现类都重写了toString()方法.
 
遍历集合的两种方法:
 
使用lamdba遍历
复制代码
 1 public class CollectionEach{
 2     public static void main(String[] args){
 3     Collection readBooks=new HashSet();
 4     readBooks.add("Java 多线程边编程的艺术");
 5     readBooks.add("Java编程思想");
 6     readBooks.add("简洁之道");
 7     readBooks.add("Effective Java");
 8     readBooks.add("程序员职业素养");
 9     readBooks.foreach(ele->System.out.println("迭代集合元素:"+ele));
10     }
11 }
复制代码
      在java8中Iterable接口新增了一个forEach(Consumser action)方法,而Iterable接口是Collection接口的父接口,因此Collection集合也可直接调用该方法。
 
      2.使用Java8增强Iterator遍历集合
 
package com.ynu.java.learn.base.MutilThread;
 
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
 
/**
 * @author root
 *
 */
public class IteratorTest
{
 
    /**
     * @param args
     */
    public static void main(String[] args)
    {
        // TODO Auto-generated method stub
        Collection<String> books = new HashSet<>();
        books.add("明朝那些事");
        books.add("三国演义!");
        books.add("水浒传!");
        books.add("Java编程思想");
 
        Iterator<String> it = books.iterator();
        while (it.hasNext())
        {
            // it.next()方法返回的数据类型是Object类型,因此需要强制类型转换
            String book = it.next();
            System.out.println(book);
            if (book.equals("三国演义!"))
            {
                it.remove();
            }
            // 对book变量赋值,不会改变集合元素本身
            book = "测试字符串";
        }
        System.out.println(books);
    }
 
}
当使用Iterator对集合元素进行迭代时,Iterator并不是把集合元素本身传给了迭代变量,而是把集合元素的值传给了迭代变量,因此修改迭代变量的值对集合元素本身没有任何影响。
 
当使用Iterator迭代访问Collection集合元素时,不能使用Collection对象修改Collection集合里的元素,但是可以使用Iterator的remove()方法删除上一次next()方法返回集合元素,否则将会引发java.util.Concurrent.ModificationException异常。
 
 
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
 
/**
 * @author root
 *
 */
public class IteratorTest
{
 
    /**
     * @param args
     */
    public static void main(String[] args)
    {
        // TODO Auto-generated method stub
        Collection<String> books = new HashSet<>();
        books.add("明朝那些事");
        books.add("三国演义!");
        books.add("水浒传!");
        books.add("Java编程思想");
 
        Iterator<String> it = books.iterator();
        while (it.hasNext())
        {
            // it.next()方法返回的数据类型是Object类型,因此需要强制类型转换
            String book = it.next();
            System.out.println(book);
            if (book.equals("三国演义!"))
            {
                books.remove("三国演义!");
            }
            // 对book变量赋值,不会改变集合元素本身
            book = "测试字符串";
        }
        System.out.println(books);
    }
 
}
  使用Java8新增的Predicate操作集合
 
       Java 8为Collection集合新增了removeIf(Predicate filter)方法,该方法将会批量删除符合条件的filter条件的所有元素。示例如下:
 
import java.util.Collection;
import java.util.HashSet;
 
/**
 * @author root
 *
 */
public class PredicateTest
{
 
    /**
     * @param args
     */
    public static void main(String[] args)
    {
        // TODO Auto-generated method stub
        Collection<String> books = new HashSet<>();
        books.add(new String("轻量级Java EE企业应用实战"));
        books.add(new String("疯狂Java讲义"));
        books.add(new String("疯狂iOS讲义"));
        books.add(new String("疯狂Ajax讲义"));
        books.add(new String("疯狂Android讲义"));
        System.out.println(books);
        // 使用lambda表达式(目标类型是Predicate)过滤集合
        books.removeIf(ele -> ele.length() < 10);
        System.out.println(books);
    }
 
}
 Predicate使用示例2:
 
 
56
import java.util.Collection;
import java.util.HashSet;
import java.util.function.Predicate;
 
/**
 * @author root
 *
 */
public class PredicateTest2
{
 
    /**
     * @param args
     */
    public static void main(String[] args)
    {
        // TODO Auto-generated method stub
        Collection<String> books = new HashSet<>();
        books.add("Java编程思想");
        books.add("Java疯狂讲义");
        books.add("代码整洁之道_程序员的职业素养");
        books.add("java并发编程的艺术");
        books.add("TensorFlow 实战深度学习框架");
        books.add("人际关系与沟通");
        books.add("Effective java");
        books.add("代码整洁之道");
        books.add("TensorFlow实战");
 
        // 统计书名包含"Java"子串的图书数量
        System.out.println(calAll(books, ele -> ((String) ele).contains("Java")));
        // 统计书名包含"疯狂"子串的图书数量
        System.out.println(calAll(books, ele -> ((String) ele).contains("疯狂")));
        // 统计书名字符长度大于10的图书数量
        System.out.println(calAll(books, ele -> ((String) ele).length() > 10));
    }
 
    /**
     * @param books
     * @param object
     * @return
     */
    private static int calAll(Collection<String> books, Predicate p)
    {
        // TODO Auto-generated method stub
        int total = 0;
        for (Object obj : books)
        {
            if (p.test(obj))
            {
                total++;
            }
        }
        return total;
    }
 
}
  使用java 8 新增的Stream操作集合
 
Java8新增了Stream、IntStream、LongStream、DoubleStream等流式API,这些API代表了多个支持串行和并行聚集操作的元素,其中Stream是一个通用的流接口,而IntStream、LongStream、DoubleStream则代表了类型为int,long,double的流。
 
      独立使用Stream的步骤如下:
 
    1、使用Stream或XxxStream的builder()类方法创建该Stream对应的Builder。
 
     2、重复调用Builder的add()方法向该流中的添加多个元素
 
     3、调用Builder的build()方法获取对应的Stream
 
     4、调用Stream的聚集方法。
 
26
package com.edu.ynu.java.learn.collection;
 
import java.util.stream.IntStream;
 
public class IntStreamTest
{
    public static void main(String[] args)
    {
        IntStream is = IntStream.builder().add(12).add(23).add(-2).add(4).build();
        //下面调用聚集方法的代码每次只能执行一次
       /* System.out.println("is所有元素的最大值:" + is.max().getAsInt());
        System.out.println("is所有元素的最小值:" + is.min().getAsInt());
        System.out.println("is所有元素的总和:" + is.sum());
        System.out.println("is所有元素的总数:" + is.count());
        System.out.println("is所有元素的平均值:" + is.average());
        System.out.println("is所有元素的平方是否都大于20:" + is.allMatch(ele -> ele * ele > 20));
        System.out.println("is是否包含任何元素的平法大于20:" + is.anyMatch(ele -> ele * ele > 20));*/
 
        //将is映射成一个新的Stream,新Stream的每个元素是原Stream元素的2倍+1
        IntStream newIs = is.map(ele -> ele * 2 + 1);
        //使用方法引用的方式来遍历集合元素
        newIs.forEach(System.out::println);
 
 
    }
}
  在Stream中方法分为两类中间方法和末端方法
 
中间方法:中间操作允许流保持打开状态,并允许直接调用后续方法。上面程序中的map()方法就是中间方法。
末端方法:末端方法是对流的最终操作。当对某个Stream执行末端方法后,该流将会被"消耗"且不再可用。上面程序中的sum()、count()、average()等方法都是末端方法。
除此之外,关于流的方法还有如下特征:
 
有状态的方法:这种方法会给你流增加一些新的属性,比如元素的唯一性、元素的最大数量、保证元素的排序的方式被处理等。有状态的方法往往需要更大的性能开销
短路方法:短路方法可以尽早结束对流的操作,不必检查所有的元素。
 
复制代码
import java.util.Collection;
import java.util.HashSet;
 
public class CollectionStream
{
    public static void main(String[] args)
    {
        Collection books = new HashSet();
        books.add("Java并发编程的艺术");
        books.add("Effective java 中文版");
        books.add("代码整洁之道");
        books.add("深度学习、优化与识别");
        books.add("代码整洁之道_程序员的职业素养");
        books.add("人际关系与沟通");
        books.add("TensorFlow实战");
        books.add("TensorFlow实战Google深度学习框架");
        books.add("明朝那些事");
 
        //统计书名包含"码"子串的图书数量
        System.out.println(books.stream().filter(ele -> ((String) ele).contains("码")).count());
        //统计书名包含"java"子串的图书数量
        System.out.println(books.stream().filter(ele -> ((String) ele).contains("Java")).count());
        //统计书名字符串长度大于10的图书数量
        System.out.println(books.stream().filter(ele -> ((String) ele).length() > 10).count());
        //先调用Collection对象的stream()方法将集合转换为Stream
        //再调用Stream的mapToInt()方法获取原有的Stream对应的IntStream
        books.stream().mapToInt(ele -> ((String) ele).length()).forEach(System.out::println);
    }
}
复制代码
Set集合
HashSet
 
HashSet是Set接口的典型的实现。HashSet按Hash算法来存储集合中的元素。在存取和查找上有很好的性能。
 
HashSet具有以下特点:
 
1、不能保证元素的排列顺序,顺序可能与添加顺序不同,顺序也有可能发生变化。
 
2、HashSet不是同步的,必须通过代码来保证其同步。
 
3、集合元素可以是null.
 
当向HashSet集合中存入一个元素时,HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值,然后根据该hashCode值决定该hashCode值决定该对象在HashSet中存储的位置。
 
如果有两个元素通过equals()方法比较返回true,但它们的hashCode()方法返回值不相等,hashSet将会把它们存储在不同位置,依然可以添加成功。如果两个对象的hashCode()方法返回的hashCode值相同,当它们的equals()方法返回false时,会在hashCode所在位置采用链式结构保存多个对象。这样会降低hashSet的查询性能。
 
综上所述:HashSet集合判断两个元素相等的标准是两个对象通过equals方法比较相等,并且两个hashCode()方法的返回值也相等。
 
在使用HashSet中重写hashCode()方法的基本原则
 
1、在程序运行过过程中,同一个对象多次调用hashCode()方法应该返回相同的值。
 
2、当两个对象的equals()方法比较返回true时,这个两个对象的hashCode()方法返回相同的值。
 
3、对象中用作equals()方法比较标准的实例变量,都应该用于计算hashCode值。
 
把对象内的每个意义的实例变量(即每个参与equals()方法比较标准的实例变量)计算出一个int类型的hashCode值。
实例变量类型 计算方式
boolean hashCode=(f?0:1);
整数类型(byte、short、char、int) hashCode=(int)f;
long hashCode=(int)(f^(f>>>32));
float hashCode=Float.floattoIntBits(f);
double long l=Double.doubleToLongBits(f); hashCode=(int)(I^(I>>>32));
引用类型  
       2.用第1步计算出来的多个hashCode值组合计算出一个hashCode值返回 
 
 1 return f1.hashCode()+(int)f2; 
 
为了避免直接相加产生的偶然相等(两个对象的f1、f2实例变量并不相等,但他们的hashCode的和恰好相等),可以通过为各个实例变量的hashCode值乘以一个质数后再相加
 
 1 return f1.hashCode()*19+f2.hashCode()*37; 
 
 
 
如果向HashSet中添加一个可变的对象后,后面的程序修改了该可变对想的实例变量,则可能导致它与集合中的其他元素的相同(即两个对象的equals()方法比较返回true,两个对象的hashCode值也相等),这就有可能导致HashSet中包含两个相同的对象。
 
复制代码
复制代码
 1 import java.util.HashSet;
 2 import java.util.Iterator;
 3 
 4 public class HashTest2
 5 {
 6     public static void main(String[] args)
 7     {
 8         HashSet hs = new HashSet();
 9         hs.add(new R(5));
10         hs.add(new R(-3));
11         hs.add(new R(-9));
12         hs.add(new R(15));
13         //打印HashSet集合,集合 元素没有重复
14         System.out.println(hs);
15         //取出第一个元素
16         Iterator it = hs.iterator();
17         R first = (R) it.next();
18         System.out.println(first.count);
19 //        为第一个元素的count实例变量赋值
20         first.count = -3;
21         System.out.println(hs);
22         //删除count为-3的R对象
23         hs.remove(new R(-3));
24         //可以看到被删除了一个R元素
25         System.out.println(hs);
26         System.out.println("hs是否包含count为-3的R对象?" + hs.contains(new R(-3)));  //输出false
27         System.out.println("hs是否包含count为-2的R对象?" + hs.contains(new R(-2)));  //输出false
28     }
29 }
30 
31 class R
32 {
33     int count;
34 
35     public R(int count)
36     {
37         this.count = count;
38     }
39 
40     public String toString()
41     {
42         return "R[count:" + count + "]";
43     }
44 
45     public boolean equals(Object obj)
46     {
47         if (this == obj)
48         {
49             return true;
50         }
51         if (obj != null && obj.getClass() == R.class)
52         {
53             R r = (R) obj;
54             return this.count == r.count;
55         }
56         return false;
57     }
58 
59     public int hashCode()
60     {
61         return this.count;
62     }
63 }
复制代码
复制代码
程序运行的结果
 
[R[count:-3], R[count:5], R[count:-9], R[count:15]]
-3
[R[count:-3], R[count:5], R[count:-9], R[count:15]]
[R[count:5], R[count:-9], R[count:15]]
hs是否包含count为-3的R对象?false
hs是否包含count为-2的R对象?false
对于上述代码的解释,在执行
 
 System.out.println("hs是否包含count为-3的R对象?" + hs.contains(new R(-3)));
时,首先去查找HashSet中通过-3计算得出的元素的位置,这里元素为-3已经删除了,所以找不到数值为-3的元素的值
对于执行
 System.out.println("hs是否包含count为-3的R对象?" + hs.contains(new R(-2)));
时,因为通过后面的修改的已经将z值为-2的元素对应的hashCode的元素的值改为-3,也就是说找到了对应的HashCode对应位置的上的元素,但是元素对应的值与-2不相等,所以返回也为false
LinkedHashSet    
 
LinkedHashSet集合也是根据hashCode值据决定元素的存储位置的,但它同时使用链表维护元素的次序,存储的顺序是元素插入的顺序。
 
LinkedHashSet需要维护元素的插入的顺序,因此性能略低于HashSet的性能,但在迭代方位Set里的全部元素时将有很好的性能,因为它以链表来维护内部顺序。
 
 
 
复制代码
 1 import java.util.LinkedHashSet;
 2 
 3 public class LinkedHashSetTest
 4 {
 5     public static void main(String[] args)
 6     {
 7         LinkedHashSet books = new LinkedHashSet();
 8         books.add("疯狂Java讲义");
 9         books.add("轻量级Java EE企业应用实战");
10         books.add("Java并发编程的艺术");
11         String a = null;
12         books.add(a);
13         System.out.println(books);
14 
15 //        删除 疯狂Java讲义
16         books.remove("疯狂Java讲义");
17 //        重新添加 疯狂Java 讲义
18         books.add("疯狂Java讲义");
19         System.out.println(books);
20     }
21 }
复制代码
 
 
TreeSet
TreeSet是SortedSet接口的实现类,TreeSet可以保证集合元素处于排序状态
 
复制代码
 1 package com.edu.ynu.java.learn.collection;
 2 
 3 import java.util.TreeSet;
 4 
 5 public class TreeSetTest
 6 {
 7     public static void main(String[] args)
 8     {
 9         TreeSet nums = new TreeSet();
10         nums.add(15);
11         nums.add(20);
12         nums.add(-1);
13         nums.add(-19);
14 //        输出集合元素,看到集合元素已经处于排序状态
15         System.out.println(nums);
16 //        输出集合中的第一个元素
17         System.out.println(nums.first());
18 //        输出集合中最后一个元素
19         System.out.println(nums.last());
20 //        返回小于4的子集,不包含4
21         System.out.println(nums.headSet(2));
22 //        返回大于5的子集
23         System.out.println(nums.tailSet(3));
24 //        返回大于等于-6,小于4的子集
25         System.out.println(nums.subSet(-6, 4));
26     }
27 }
复制代码
TreeSet采用红黑树的数据结构来存储集合元素
 
TreeSet支持两种的排序方法:自然排序和定制排序,在默认的情况下,TreeSet采用自然排序
 
1、自然排序
 
TreeSet会调用集合元素的compareTo(Oject obj)方法来比较元素之间的大小关系,然后将集合元素按升序排列
 
如果试图把一个对象添加到TreeSet时,则该对象的类必须实现Comparable接口,否则程序将会抛出异常
 
复制代码
1 class Err{}
2 public class TreeSetErrorTest
3 {
4    public static void main(String[] args){
5     TreeSet ts=new TreeSet();
6     ts.add(new Err());
7     ts.add(new Err());
8 }
9 }
复制代码
上述代码没有实现的Comparable接口,则会引发ClassCastException异常。
 
向TreeSet中添加的应该是同一类的对象否则也会引发ClassCastException异常。
 
对于TreeSet集合而言,它判断两个对象的是否相等的唯一标准是:两个对象的通过compareTo(Object obj)方法比较是否返回0--如果通过compareTo(Object obj)方法比较返回0,TreeSet则会认为它们相等,否则认为它们不相等。