jav核心（十四）：集合类型操作：Collection、List、Set；Map集合；Iterator迭代器

时间：2019-03-20 19:39:31 阅读：115 评论：0 收藏：0 [点我收藏+]

一、java.util.List

1、List总结

List中允许保存重复的数据；
List中允许保存多个null；
常用实现类：ArrayList【推荐使用】、Vector、LinkedList；
List中数据是有序的，按照数据添加顺序进行排序；
由于List是有序的，因此List新增加了一个方法：E get(int index) ，【Collection、Set接口均没有get(int index)方法】。

2、ArrayList和Vector的区别

　　ArrayList和Vector，都是List接口的实现类。

NO	区别点	ArrayList	Vector
1	推出时间	JDK1.2，属于新增类	JDK1.0，属于旧类
2	性能	异步处理	同步处理方法采用synchronized修饰，为同步方法
3	安全	非线程安全	线程安全
4	数据输出方式	Iterator、ListIterator、foreach	Iterator、ListIterator、foreach、 Enumeration

3、Vertor向量类型数据输出：Vertor --> Iterator | Enumeration

　　Java.util.Vertor是JDK1.0中设计的向量类型。后来在JDK1.2中新增了Collection、List、Set接口，为保持集合统一型，修改Vertor类的定义，使其实现了List接口。与新集合的实现不同，Vertor是同步的。

　　Java.util.Enumeration是JDK1.0中定义的接口，和Java.util.Iterator（JDK1.2出现）迭代器功能类似。其中Enumeration接口包含两个方法：

hasMoreElements()：测试此枚举是否包含更多的元素。
nextElement()：如果此枚举对象至少还有一个可提供的元素，则返回此枚举的下一个元素。

public class Test {
    public static void main(String[] args) {
        List<String> vertor = new Vector<String>();
        vertor.add("A");
        vertor.add("B");
        vertor.add("C");
        //输出数据：使用迭代器Iterator
        Iterator<String> iterator = vertor.iterator();
        while (iterator.hasNext()){
            String data = iterator.next();
            System.out.println(data);
        }
 
        System.out.println("*******");
        //输出数据：使用Enumeration
        Enumeration<String> enumeration = ((Vector<String>) vertor).elements();
        while (enumeration.hasMoreElements()){
            String data = enumeration.nextElement();
            System.out.println(data);
        }
    }
}

//程序运行结果：
A
B
C
*******
A
B
C

二、Java.util.Set

1、Set总结

　　API描述：一个不包含重复元素的 collection。更正式地说，set 不包含满足 e1.equals(e2) 的元素对 e1 和 e2，并且最多包含一个 null 元素。正如其名称所暗示的，此接口模仿了数学上的 set 抽象。

Set不允许保存重复的数据【不同实现类，对重复数据的评定标准不一样】；
常用实现类：HashSet、TreeSet；
HashSet允许保存一个null，TreeSet不允许保存null；
HashSet中的数据是无序的；
TreeSet中的数据是有序的，数据按照升序排列【通过调用数据元素的compareTo()方法进行排序，因此数据元素需要实现Comparable接口，否则会抛出ClassCastException异常】。

2、HashSet中，数据重复的评定标准：

　　当且仅当( e1.hashCode() == e2.hashCode() ) && e1.equals(e2) 为true时，才认定e1和e2重复。

　　（1）数据重复测试一：e1.equals(e2)为true时，hashCode()值必然相同的情况

/**
 * 按照规范重写Book类的equals()方法、hashCode()方法
 */
class Book {
    private int price;
    private String name;
    public Book(int price, String name) {
        this.price = price;
        this.name = name;
    }
 
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Book book = (Book) o;
        return price == book.price &&
                Objects.equals(name, book.name);
    }
 
    @Override
    public int hashCode() {
        return Objects.hash(price, name);
    }
 
    @Override
    public String toString() {
        return this.name + "--" + this.price;
    }
}
 
 
public class Test {
    public static void main(String[] args) {
        Book book = new Book(100, "java开发");
        Book book1 = new Book(100, "java开发");
        Book book2 = new Book(100, "设计模式");
        Book book3 = new Book(10, "abc");
 
        System.out.println("*********");
        System.out.println(book.hashCode());     //-1166307760
        System.out.println(book1.hashCode());    //-1166307760
        System.out.println(book2.hashCode());    //1100964814
        System.out.println(book.equals(book1));    //true
        System.out.println(book.equals(book2));    //false
        System.out.println("*********");
 
        Set<Book> hashSet = new HashSet<>();
        hashSet.add(book);
        hashSet.add(book1);     //book1 与 book 重复，不进行保存
        hashSet.add(book2);     //book2 不重复
        hashSet.add(book3);     //book3 不重复
        System.out.println(hashSet);
    }
}

//程序执行结果：
*********
-1166307760
-1166307760
1100964814
true
false
*********
[设计模式--100, abc--10, java开发--100]

　　（2）数据重复测试二：e1.equals(e2)为true，但hashCode()值不同的情况

class Book {
    private int price;
    private String name;
    public Book(int price, String name) {
        this.price = price;
        this.name = name;
    }
    @Override
    public String toString() {
        return this.name + "--" + this.price;
    }
 
 
    //任何对象之间比较，均返回true
    public boolean equals(Object o) {
        return true;
    }
 
    //使用随机数生成hashCode
    public int hashCode() {
        return Objects.hash(Math.random());
    }
}
 
 
public class Test {
    public static void main(String[] args) {
        Book book = new Book(100, "java开发");
        Book book1 = new Book(100, "java开发");
        Book book2 = new Book(100, "设计模式");
 
 
        System.out.println("*********");
        System.out.println(book.hashCode());
        System.out.println(book1.hashCode());
        System.out.println(book2.hashCode());
        System.out.println(book.equals(book1));
        System.out.println(book.equals(book2));
        System.out.println("*********");
 
 
        Set<Book> hashSet = new HashSet<>();
        hashSet.add(book);
        hashSet.add(book1);     //book1 与 book 重复
        hashSet.add(book2);     //book2 不重复
        System.out.println(hashSet);
    }
}

//程序执行结果
*********
920603493
-1541131927
1273275611
true
true
*********
[java开发--100, 设计模式--100, java开发--100]

3、TreeSet中，数据重复的评定标准：

　　TreeSet<T>中的元素T必须实现java.lang.Comparable接口，重写接口定义的 public int compareTo(T o) 方法。

　　当且仅当 e1.compareTo(e2) 返回结果为0时，认为e1、e2重复。

　　TreeSet不使用equals()、hashCode()方法进行判定。

class Book implements Comparable{
    private int price;
    private String name;
    public Book(int price, String name) {
        this.price = price;
        this.name = name;
    }
    @Override
    public String toString() {
        return this.name + "--" + this.price;
    }
 
 
    @Override
    public boolean equals(Object o) {
        return true;
    }
 
 
    @Override
    public int hashCode() {
        return Objects.hash("1111");
    }
 
 
    @Override
    public int compareTo(Object o) {
        return 1;
    }
}
 
 
public class Test {
    public static void main(String[] args) {
        Book book = new Book(100, "java开发");
        Book book1 = new Book(100, "java开发");
        Book book2 = new Book(100, "设计模式");
 
        System.out.println("*********");
 
        Set<Book> hashSet = new TreeSet<>();
        hashSet.add(book);
        hashSet.add(book1);     
        hashSet.add(book2);     
        System.out.println(hashSet);
    }
}

//程序执行结果
*********
[java开发--100, java开发--100, 设计模式--100]

4、说明：一般情况下，比较两个对象是否相同，通过hashCode()和equals()方法判断

首先判断hashCode()值是否相等，如果不相等，则认为e1、e2不相同；如果相等，则继续判断e1.equals(e2)是否为true，若为true则认为e1、e2相同，否则认为e1、e2不相同；
Comparable的compareTo()方法只是作为对象的排序使用，但并不能真正区分两个对象是否相同。

三、Java.util.Map

1、Map总结

将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射一个值。

//语法定义
public interface Map<K,V>

2、Map接口中的方法

NO	方法名称
1	public V put(K key, V value) 将指定的值与此映射中的指定键相关联（可选操作）。
2	public V get(Object key) 返回此映射中映射到指定键的值。
3	public Set<Map.Entry<K,V>> entrySet() 返回此映射中包含的映射关系的 set 视图。
4	public Set<K> keySet() 返回此映射中包含的键的 set 视图。

3、HashMap和HashTable的区别

NO	区别点	HashMap	HashTable
1	推出时间	JDK1.2，属于新增类	JDK1.0，属于旧类
2	性能	异步处理	同步处理方法采用synchronized修饰
3	安全	非线程安全	线程安全
4	是否允许null	允许key或value为null	key和value均不能为null

4、将Map中的数据，通过迭代器输出：Map —> Set —> Iterator

调用Map.entrySet()方法，将Map集合转换为Set集合，其中Set中的泛型为：Map.Entry<K,V>;
调用Set.iterator()方法，将Set集合转换为Iterator迭代器，泛型依然是：Map.Entry<K,V>;
调用Iterator的hasNext()、next()方法，循环取出Map.Entry<K,V>接口对象；
调用Map.Entry接口的getKey()获取key、getValue()获取value。

技术分享图片

class Book {
    private int price;
    private String name;
    public Book(int price, String name) {
        this.price = price;
        this.name = name;
    }
    @Override
    public String toString() {
        return this.name + "--" + this.price;
    }
}
 
 
public class Test {
    public static void main(String[] args) {
        Book book = new Book(100, "java开发");
        Book book1 = new Book(100, "java开发");
        Book book2 = new Book(56, "设计模式");
 
        System.out.println("*********");
        Map<String,Book> map = new HashMap<>();
        map.put("book",book);
        map.put("book1",book1);
        map.put("book2",book2);
 
        //将Map中的数据，通过迭代器输出：Map —> Set  —> Iterator
        Set<Map.Entry<String,Book>> set = map.entrySet();
        Iterator<Map.Entry<String,Book>> iterator = set.iterator();
        while (iterator.hasNext()){
            Map.Entry<String,Book> entry = iterator.next();
            String key = entry.getKey();
            Book value = entry.getValue();
            System.out.println(key+" : "+value);
        }
    }
}

//程序执行结果
*********
book2 : 设计模式—56
book1 : java开发--100
book : java开发--100

jav核心（十四）：集合类型操作：Collection、List、Set；Map集合；Iterator迭代器

原文：https://www.cnblogs.com/newbie27/p/10566886.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)