10.集合Set

 

一,可变参数

1,   可变参数是在jdk1.5以后函数的参数可以定义为可变参数

可变参数的定义方式为(类型...变量名);  注意:”...” :只能是3个

可变参数可以接受指定类型的0到多个实参,也可以接受指定类型的一个数组;

这些实参都会传入到形参变量代表的数组中,传了几个实参,形参数组的长度就是几

可变参数必须是参数列表的最后一个;

2,什么时候使用可变参数

当我们定义一个函数的时候,如果需要接收的数据个数不确定,那么就定义为可变参数

这样别人使用我们的方法时,可以按照实际需求传入不同数量的实参

例:

importjava.util.Arrays;

publicclass ParamMehodDemo {

 

   /**Java1.5的新特性:

   publicstaticvoid main(String[] args) {

      show1(1,3,4,6,7);

      show("c",3,2,5);

   }

   privatestaticvoid show1(int... arr) {

      System.out.println(arr.length);

   }

   publicstaticvoid show(String str,int... arr) {

      System.out.println(arr.length);

   }

}

二,List的分类

1,ArrayList

数组结构,查找块

2,LinkedList

链表结构,增删块

也是一种队列的实现,可以使用remove方法获取对首的元素;

3,Vector

和ArrayList原理相同,但线程安全,效率略低

拥有一种自己特有的迭代方式:枚举;

使用elements()方法可以获取一个Enumeration接口,调用hasMoreElements()方法是否包含下一个,调用nextElements()获取下一个;

4,Stack: 堆栈结构;

Stack是一种栈结构的容器,先存的元素最后被取出,后存的元素先被取出;

       5.Queue:队列结构

              Queue是队列结构,先进先出,后进后出;

三,Set集合

1,HashSet

除掉重复,没有顺序

HashSet的add方法会调用hashCode和equals,所以存储在HashSet中的对象需要重写这两个方法;

/**hashSet工作原理:

每次存储对象的时候,调用对象的hashCode方法,计算一个哈希值,在集合中查找是否包含与哈希值相同的元素;

    *              如果没有哈希值相同的元素,直接存入;

    *              如果有哈希值相同的元素,逐个使用equals方法比较

    *                 比较结果全为false则存入

    *                 比较结果有为true则不存;

    */

如何将自定义类对象存入HashSet进行去重复

 *    类中必须重写hashCode()方法和equals()方法

 *    equals()方法中比较所有属性

*     hashCode()方法要保证属性相同的对象返回值相同,属性不同的对象尽量不同

举例:

package cn.itcast;

 

//定义Person类,实现comparable 

publicclass Personimplements Comparable<Person> {

   private Stringname;    //成员变量私有;

   privateintscore;

   privateintnum;

 

   // 定义有参构造函数;

   public Person(String name,int score,int num) {

      this.name = name;

      this.score = score;

      this.num = num;

   }

 

   //

   @Override

   // 重写hashCode方法

   publicint hashCode() {

      finalint prime = 31;

      int result = 1;

      result= prime * result + ((name ==null) ? 0 :name.hashCode());

      result= prime * result + score;

      result= prime * result + num;

      return result;

   }

 

   @Override

   // 重写equals方法

   publicboolean equals(Object obj) {

      if (this == obj)

         returntrue;

      if (obj ==null)

         returnfalse;

      if (getClass() != obj.getClass())

         returnfalse;

      Person other = (Person) obj;

      if (name ==null) {

         if (other.name !=null)

            returnfalse;

      }elseif (!name.equals(other.name))

         returnfalse;

      if (num != other.num)

         returnfalse;

      if (score != other.score)

         returnfalse;

      returntrue;

   }

 

   @Override

   // 重写toString方法

   public String toString() {

      return"Person>>[name=" +name + "  >>score=" + score +"  >>num="+ num + "]";

   }

 

   /*

    * 使用当前对象和另一个Person比较大小如果当前对象小,返回负数 如 *果当前对象大,返回正数 如果等于,返回0;

    */

   publicint compareTo(Person p) {

      int i = p.score -this.score;

      // 比较分数大小;

      return i != 0 ? i : (p.num-this.num);

}

}

package cn.itcast;

//导包

import java.util.HashSet;

 

publicclass HashSetDemo {

   publicstaticvoid main(String[] args) {

      // 创建HashSet集合

      HashSet<Person>hs = new HashSet<Person>();

//    new Person (name, score,num)

      hs.add(new Person("李斯",59,1000));

      hs.add(new Person("嬴政",60,10000));

      hs.add(new Person("子婴",59,5665));

      hs.add(new Person("项羽",60,8899));

     

      hs.add(new Person("子婴",60,9988));

      hs.add(new Person("子婴",59,5665));

      hs.add(new Person("项羽",60,9900));

     

     

      //增强for循环;

      for(Person p:hs)

         System.out.println(p);

   }

 

}

2,LinkedHashSet

是HashSet的子类,除去重复,且保留原存储顺序

3,TreeSet

除掉重复,且可以按照某种顺序排序

可以对Set集合中的元素进行排序。

       底层数据结构是二叉树。

       保证元素唯一性的依据： compareTo方法return 0.

TreeSet排序的第一种方式：让元素自身具备比较性。

                           元素需要实现Comparable接口，覆盖compareTo方法。

                           也种方式也成为元素的自然顺序，或者叫做默认顺序。

TreeSet的第二种排序方式:

       当元素自身不具备比较性时，或者具备的比较性不是所需要的。

       这时就需要让集合自身具备比较性。

       在集合初始化时，就有了比较方式。

定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。

定义一个类，实现Comparator接口，覆盖compare方法。

注意:排序时，当主要条件相同时，一定判断一下次要条件。

当两种排序都存在时，以比较器为主。

举例: 调用上面的Person类

package cn.itcast;

 

import java.util.TreeSet;

 

publicclass TreeSetDemo {

   publicstaticvoid main(String[] args) {

      // 创建一个TreeSet集合,

      TreeSet<Person>ts = new TreeSet<Person>();

      ts.add(new Person("刘邦", 95, 10000));

      ts.add(new Person("项羽", 70, 1000));

      ts.add(new Person("张良", 87, 8899));

      ts.add(new Person("陈平", 85, 7788));

     

      ts.add(new Person("刘邦", 55, 5555));

      ts.add(new Person("陈平", 59, 5566));

      ts.add(new Person("项羽", 70, 8877));

//遍历ts,按顺序打印出不重复的对象;

      for (Person p : ts)

         System.out.println (p);

   }

 

}

class MyComparatorimplementsComparator {

   publicint compare(Object o1,Object o2) {

      Person p1 = (Person)o1; 

//强制类型转换,将集合中取出的对象转成Person类,然后根据Person属性进行比较

      Person p2 = (Person)o2;

//比较人名是否相同

      int i = p1.getName().compareTo(p2.getName());

//如果人名相同,比较学号是否相同,如果都相同,说明是同一个人,不比较分数;

      if(i == 0)

         returnnew Integer(p1.getNum()).compareTo(new Integer(p2. getNum ()));

      return i;

   }

}

4,迭代方式

1,使用迭代器Iterator

for(Iterator iter = set.iterator();iter.hasNext();) {

System.out.println(iter.next());

}

2,使用增强for循环;

for(Object obj : ts) {

System.out.println(obj);

}

              3.TreeSet特有:逆向迭代(descendingIterator).Java1.6版本新特性;

                    例:

                    TreeSet<String> ts = new TreeSet<String>();

         ts.add("zzz");

         ts.add("aaa");

         ts.add("cab");

         ts.add("xx");                   

Iterator it = new TreeSet().descendingIterator();

                     while(it.hasNext())

                            System.out.println(it.next());

                    //获取集合中按自然顺序排列的第一个元素,并从集合中移除,改变集合长度;java1.6新特性,如果set集合为空,返回null

      System.out.println("ts.pollfirst="+ts.pollFirst());

      System.out.println(ts.size());

                           打印结果:  zzz

xx

cab

aaa

ts.pollfirst=aaa

3

5,小结:

1,学会hashSet

2,学会TreeSet

3,学会迭代方式;