服务器之家:专注于服务器技术及软件下载分享
分类导航

PHP教程|ASP.NET教程|Java教程|ASP教程|编程技术|正则表达式|C/C++|IOS|C#|Swift|Android|VB|R语言|JavaScript|易语言|vb.net|

服务器之家 - 编程语言 - Java教程 - java 中Collection存储器详解及简单实例

java 中Collection存储器详解及简单实例

2020-09-08 10:48sy_y Java教程

这篇文章主要介绍了java 中Collection存储器详解及简单实例的相关资料,需要的朋友可以参考下

本篇仅为了巩固一下基础,回忆一下存储的这两个常用的东东…

一、Collection

1.存储对象可以考虑:①数组②结合

2.数组存储对象的特点:Student[] stu = new Student[20]; stu[0] = new Stutdent();……

弊端:①一旦创建,其长度不可变
    ②真实的数组存放的对象的个数是不可知的

3.集合

Collection接口
    丨------List接口:存储有序,可以重复的元素
        丨-------ArrayList(主要的实现类,首选)
        丨-------LinkedList(频繁的插入,删除)
        丨-------Vector(古老的实现类,线程安全)
    丨------Set接口:存储无序,不可重复的元素,Set中常用的方法都是Collection下定义的
        丨-------HashSet(主要实现类)
        丨-------LinkedHashSet
        丨-------TreeSet

例: (这里主要是说Set接口)

1)HashSet

Set存储的元素是无序的,是不可重复的!

1.无序性:无序性 != 随机性。真正的无序性,指的是元素在底层存储的位置是无序的。(根据hash值来存)

2.不可重复性:当向Set中添加进相同的元素的时候,后面的这个不能添加进去。

java" id="highlighter_891727">
?
1
//说明:要求添加进Set中的元素所在的类,一定要重写equals()和hashcode()方法。进而保证set中元素的不可重复性!

set中的元素时如何存储的呢?使用了哈希算法。

当向set中添加元素时,首先调用此对象所在类的hashCode()方法,计算此对象的hash值,此哈希值决定了此对象在set中的存储位置,若此位置之前没有对象存储,则此对象直接存到这个位置。(就好比一个教室,按号入座一样),若已有对象存储,在通过equals()方法比较这两个对象的是否相同,如果相同后一个对象不能再添加进来。

万一返回false呢?都存储。(不建议如此)

?
1
//>要求:hashcode()方法要与equals()方法一致。

事例代码如下:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class TestSet{
 
  @Test
  public void testHashSet(){
    Set set = new HashSet();
    set.add(123);
    set.add(456);
    set.add(new String("AA"));
    set.add(new String("AA"));//若此时在这里加上相同元素,则加不进去。
    set.add("BB");
    set.add(null);
    System.out.println(set.size());
    System.out.println(set);
  }
}

2)LinkedHashSet()

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
/*
 *LinkedHashSet:使用链表维护了一个添加进集合中的顺序,导致当我们遍历LinkedHashSet集合元素是按照
 *添加进去的顺序遍历的!但是存储是无序的!
 *LinkedHashSet得插入性能略低于HashSet,但在迭代访问Set里的全部元素时有很好的性能。
 *LinkedHashSet不允许集合元素重复。
 */
public class TestLinkedHashSet{
 
  @Test
  public void testLinkedHashSet(){
    Set set = new LinkedHashSet();
    set.add(123);
    set.add(456);
    set.add(new String("AA"));
    set.add(new String("AA"));
    set.add("BB");
    set.add(null);
    System.out.println(set.size());
    System.out.println(set);
 
    //迭代器去遍历
    Iterator iterator = set.iterator();
    while(iterator.hasNext()){
      System.out.println(iterator.next());
    }
  }
}
输出为:123,456,AA,BB,null

3)TreeSet

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
/*
 *1.向TreeSet中添加的元素必须是同一个类的
 *2.可以按照添加进集合中的元素的指定的顺序遍历,像String,包装类等默认按照从小到大的顺序遍历
 *3.当向TressSet中添加自定义类的对象时,有两种排序方法:①自然排序②定制排序
 *4.自然排序:要求自定义类实现java.lang.Comparable接口并重写其compareTo(Object obj)
  在此方法中,指明按照自定义类额哪个属性进行排序。
 *5.向TreeSet中添加元素时,首先按照compareTo()进行比较,一旦返回0,虽然仅是两个对象的子属性值相同,  但是程序会认为这两个对象是相同的,进而后一个对象就不能添加进来。
 *>compartTo()与hashCode();以及equals()三者保持一致!
 */
False:
public class TestTreeSet{
  //这样添加会报出一个CastException,会出现异常
  @Test
  public void testTreeSet(){
    Set set = new TreeSet();
    set.add(123);
    set.add(456);
    set.add(new String("AA"));
    set.add(new String("AA"));
    set.add("BB");
  }
}
True:
public class TestTreeSet{
 
  @Test
  public void testTreeSet(){
    Set set = new TreeSet();
//   set.add(new String("AA"));
//   set.add(new String("AA"));//相同的元素没有进去
//   set.add("JJ");
//   set.add("GG");
//   set.add("MM");
 
    //String没有报错是以为String类型实现了Comparable接口,已经重写好了排序的方法
 
    //当Person类没有实现Comparable接口时,当向TreeSet中添加Person对象时,报   //ClassCastException
    set.add(new Person("CC",23));
    set.add(new Person("MM",21));
    set.add(new Person("GG",25));
    set.add(new Person("JJ",24));
    set.add(new Person("KK",20));//新加一个KK,但是age相同
    set.add(new Person("DD",20));
 
    for(Object str : set){
      System.out.println(str);
    }
  }
}
输出为AA,GG,JJ,MM
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
//当向TreeSet中添加Person类的对象时,依据此方法,确定按照哪个属性排列。
//需要重写compareTo方法
//Person(name,age,get/set方法,空构造器,toString,equals,hashCode)
 
  @Override
  public int compareTo(Object o){
    if(o instanceof Person){
      Person p = (Person)o;
    // return this.name.compareTo(p.name);  从小往大排
    // return -this.name.compareTo(p.name);  从大往小排
      int i = this.age.compareTo(p.age);
      if(i == 0){
        return this.name.compareTo(p.name);
      }else{
        return i ;
      }
    }
    return 0;
  }
//定制排序
 
//Customer(name,id,get/set方法,空构造器,toString,equals,hashCode)
public class TestTreeSet{
 
  @Test
  public void testTreeSet2(){
  //1.创建一个实现了Comparator接口的类对象
    Comparator com = new Comparator(){
      //
      @Override
      public int compare(Object o1,Object o2){
        if(o1 instanceof Customer && o2 instanceof Customer){
          Customer c1 = (Customer)o1;
          Customer c2 = (Customer)o2;
          int i = c1.getId().compareTo(c2.getId());
          if(i == 0){
            return c1.getName().compareTo(c2.getName());
          }
          return i;
        }
        return 0;
      }
    };
    //2.将此对象作为形参传递给TreeSet的构造器中
    TreeSet set = new TreeSet(com);
    //3.向TreeSet中添加Comparator接口中的compare方法中涉及的类的对象
    set.add(new Customer("AA",1003));
    set.add(new Customer("BB",1002));
    set.add(new Customer("GG",1004));
    set.add(new Customer("CC",1001));
    set.add(new Customer("DD",1001));
 
    for(Object str : set){
      System.out.println(str);
    }
  }
}

感谢阅读,希望能帮助到大家,谢谢大家对本站的支持!

延伸 · 阅读

精彩推荐