浅谈java中的集合类

来源：互联网发布：ubuntu更新软件的方法编辑：程序博客网时间：2024/05/16 10:53

一,简述集合类

1. 由于对象用于封装特有数据,对象多了需要存储,如果对象个数不确定,就使用集合容器进行存储.

2.集合的特点:

(1).用于存储对象的容器.

(2).集合的长度是可变的.

(3).集合中不可以存储基本数据类型值.

3.集合容器因为内部的数据结构部同,有多种具体容器,不断向上抽取,就形成了集合框架.

二.集合框架

1.Collection,集合框架中的顶层接口,与Map集合并列,一次添加一个元素.

|--List:有序(存入和取出的顺序一致),元素都有索引(特有方法:可操作角标,可完成对元素的增删改查),元素可以重复.

|--Vector:内部是数组数据结构,是同步的,增删和改查速度都慢,现已被ArrayList取代.

|--ArrayList:内部是数组数据结构,是不同步的,查询速度快.

|--LinkedList:内部是链表数据结构,是不同的,增删元素的速度快.

|--Set:元素不可重复,无序,Set接口中的方法和Collection一致.

|--HashSet:内部数据结构是哈希表,不同步,无序,可保证数据唯一性.

|--TreeSet:可以对Set集合中的元素进行排序,是不同步的.

(1).HashSet集合保证集合元素唯一性的方法:

通过对象的hashCode和equals方法来完成对象的唯一性:

1).如果对象的hashCode值不同,那么不同判断equals方法，就直接存储到哈希表中;
2).如果对象的hashCode值相同，那么要再次判断对象的equals方法是否为true,如果为true，视为相同元素，不存。如果为false，那么视为不同元素，就进行存储。
记住：如果元素要存储到HashSet集合中，必须覆盖hashCode方法和equals方法。
一般情况下，如果定义的类会产生很多对象，比如人，学生，书，通常都需要覆盖equals，hashCode方法。
建立对象判断是否相同的依据。如下面的代码:

public class Person implements Comparable {private String name;private int age;public Person() {super();// TODO Auto-generated constructor stub}public Person(String name, int age) {super();this.name = name;this.age = age;}   @Overridepublic int hashCode() {return name.hashCode()+age;}@Overridepublic boolean equals(Object obj) {    Person p = (Person)obj;return this.name.equals(p.name) && this.age == p.age ;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}

(2).TreeSet集合判断元素唯一性的方式是根据比较方法的返回值结果是否是0,是0就是相同元素,不存.TreeSet对元素进行排序的方式
如下:

1).让元素自身具备比较功能，元就需要实现Comparable接口。覆盖compareTo方法。

@Overridepublic int compareTo(Object o) {  // 覆盖comparable接口中compareTo方法/*下面代码操作的是(按年龄)以正序的方式排序,如果想以反序 * Person p = (Person)o; * if(this.age>p.age)return 1;  if(this.age<p.age)return -1;     return 0; * return 0; *  *      的方式排序可互换this和p的位置*/Person p = (Person)o; //按年龄排int temp = this.age - p.age;return temp ==0?this.name.compareTo(p.name):temp;//按姓名排//int temp = this.name.compareTo(p.name);//return temp ==0?this.age-p.age:temp;}

但如果不要按照对象中具备的自然顺序进行排序,对象中不具备自然顺序可以使用TreeSet集合第二种排序方式二:
2).让集合自身具备比较功能，定义一个类实现Comparator接口，覆盖compare方法。将该类对象作为参数传递给TreeSet集合的构造函数。

package cn.itheima;import java.util.Comparator;import cn.itheima.Person;/**TreeSet集合第二种排序方式二：让集合自身具备比较功能，定义一个类实现Comparator接口，覆盖compare方法。将该类对象作为参数传递给TreeSet集合的构造函数 *  * 创建一个根据Person类的name进行排序的比较器 * */public class ComparatorByName implements Comparator {@Overridepublic int compare(Object o1, Object o2) {Person p1 = (Person)o1;Person p2 = (Person)o2;int temp = p1.getName().compareTo(p2.getName());return temp ==0?p1.getAge()-p2.getAge():temp;}}

package cn.itheima;import java.util.Comparator;import java.util.Iterator;import java.util.Set;import java.util.TreeMap;public class TreeMapTest {public static void main(String[] args) {TreeMap tm = new TreeMap(new MyComparator());tm.put("21", "jack");tm.put("31", "rose");tm.put("41", "lucy");tm.put("51", "tony");Set keySet = tm.keySet();Iterator it = keySet.iterator();while(it.hasNext()){Object key = it.next();Object value = tm.get(key);System.out.println(key+".."+value);}}}

2. Map集合:集合框架的顶层接口,与Collecton并列,map也称为双列集合,一次添加一对元素.其实Map集合中存储的就是键值对,Map集合中必须保证键的

唯一性.

|---Hashtable:内部结构是哈希表,不允许null作为键,null作为值.

|--Properties:用来存储键值对型的配置文件的信息,可以IO技术相结合.

|--HashMap:内部结构是哈希表,不是同步的.允许null作为键,null作为值.

|--TreeMap:内部结构是二叉树,不是同步的.可以对Map集合中的键进行排序.

1).取出Map中元素的方式:

|-- 通过keySet方法获取map中所有的键所在的set集合,再通过set的迭代器获取到每一个键,然后再对每一个键通过map集合的get方法获取其对应的值即可.如:

|--通过Map.entry将键和值的映射关系作为对象存储到Set集合中

pubpackage cn.itcast.p6.map.demo;import java.util.Collection;import java.util.HashMap;import java.util.Iterator;import java.util.Map;import java.util.Set;public class MapDemo {public static void main(String[] args) {Map<Integer,String> map = new HashMap<Integer,String>();method_2(map);}public static void method_2(Map<Integer,String> map){map.put(8,"zhaoliu");map.put(2,"zhaoliu");map.put(7,"xiaoqiang");map.put(6,"wangcai");Collection<String> values = map.values();Iterator<String> it2 = values.iterator();while(it2.hasNext()){System.out.println(it2.next());}/* * 通过Map转成set就可以迭代。 * 找到了另一个方法。entrySet。 * 该方法将键和值的映射关系作为对象存储到了Set集合中，而这个映射关系的类型就是Map.Entry类型(结婚证) *  *  */Set<Map.Entry<Integer, String>> entrySet = map.entrySet();Iterator<Map.Entry<Integer, String>> it = entrySet.iterator();while(it.hasNext()){Map.Entry<Integer, String> me = it.next();Integer key = me.getKey();String value = me.getValue();System.out.println(key+"::::"+value);}//取出map中的所有元素。//原理，通过keySet方法获取map中所有的键所在的Set集合，在通过Set的迭代器获取到每一个键，//在对每一个键通过map集合的get方法获取其对应的值即可。/*Set<Integer> keySet = map.keySet();Iterator<Integer> it = keySet.iterator();while(it.hasNext()){Integer key = it.next();String value = map.get(key);System.out.println(key+":"+value);}*/}

3).Collections:Collections 是一个包装类。它包含有各种有关集合操作的静态方法。此类不能实例化，就像一个工具类，服务于Java的Collection框架。

Java代码  
import java.util.ArrayList;  
import java.util.Collections;  
import java.util.List;  
  
public class TestCollections {  
      
    public static void main(String args[]) {  
        //注意List是实现Collection接口的  
        List list = new ArrayList();  
        double array[] = { 112, 111, 23, 456, 231 };  
        for (int i = 0; i < array.length; i++) {  
            list.add(new Double(array[i]));  
        }  
        Collections.sort(list);  
        for (int i = 0; i < array.length; i++) {  
            System.out.println(list.get(i));  
        }  
        // 结果：23.0 111.0 112.0 231.0 456.0  
    }  
}  

4.Arrays:是一个包装类。它包含有各种有关集合操作的静态方法.

5.泛型

jdk1.5出现的安全机制。

好处：
1)，将运行时期的问题ClassCastException转到了编译时期。
2)，避免了强制转换的麻烦。

3),<>什么时候用？当操作的引用数据类型不确定的时候。就使用<>。将要操作的引用数据类型传入即可.
其实<>就是一个用于接收具体引用数据类型的参数范围。在程序中，只要用到了带有<>的类或者接口，就要明确传入的具体引用数据类型。泛型技术是给编译器使用的技术,用于编译时期。确保了类型的安全。运行时，会将泛型去掉，生成的class文件中是不带泛型的,这个称为泛型的擦除。为什么擦除呢？因为为了兼容运行的类加载器。泛型的补偿：在运行时，通过获取元素的类型进行转换动作。不用使用者在强制转换了。
4),泛型的通配符：? 未知类型。
5).泛型的限定：
? extends E: 接收E类型或者E的子类型对象。上限一般存储对象的时候用。比如添加元素 addAll.
? super E: 接收E类型或者E的父类型对象。下限一般取出对象的时候用。比如比较器。

0 0