zoukankan      html  css  js  c++  java

  • 集合类——Collection、List、Set接口

    集合类

    Java类集

    我们知道数组最大的缺陷就是：长度固定。从jdk1.2开始为了解决数组长度固定的问题，就提供了动态对象数组实现框架——Java类集框架。Java集合类框架其实就是Java针对于数据结构的一种实现。

    Java类集的本质就是动态对象数组。

    在Java类集中提供有两个最为核心的接口：Collection和Map接口。

    1、Collection接口

    （1）定义:

    public interface Collection<E> extends Iterable<E>

    Collection是单个集合保存的最大接口。

    Collection与写过的链表类似，每一次进行数据操作的时候只能对单个对象进行处理。且从jdk1.5开始追加泛型应用，这样可以避免ClassCastException异常的出现，里面的所有保存数据类型应该相同。

    （2）常用方法

    向集合中添加元素：boolean add(E e)

    向集合中添加一组元素：boolean addAll(Collection<? extends E> c)

    清空集合数据： void clear()

    查找数据是否存在：boolean contains(Object o)

    删除数据:boolean remove(Object o)

    取得集合长度：int size()

    将结合变为对象数组：Object[] toArray()

    取得Iterator接口对象，用于集合输出：Iterator<E> iterator()

    实则Collection接口只是一个存储数据的标准，并不能用来区分存储类型。如：需要区分可存储数据的重复与否。所以我们一般用来使用的是Collection的两个子接口：List和Set。

                  

    2、List接口

    public interface List<E> extends Collection<E>

    新增方法：

    根据索引取得保存数据: E get(int index)

    修改数据： E set(int index, E element)

    List接口与Collection接口相比，比其增加了一个get()、set()方法，可以通过指定的索引值取得修改、内容。要想取得接口的实例化对象则其必须有子类，在List接口下有三个常用子类：ArrayList、Vector、LinkedList.

                   

    （1）ArrayList

    public class ArrayList<E> extends AbstractList<E>

    ArrayList是针对于List的数组实现。

    1. package mycollection;
    2.  
    3.  
    4.  
    5. import java.util.*;
    6.  
    7.  
    8.  
    9. public class Test {
    10.  
    11. public static void main(String[] args) {
    12.  
    13. //这时候集合中只能存String类型的数据
    14.  
    15. List<String> list = new ArrayList<>();
    16.  
    17. list.add("hello");
    18.  
    19. list.add("world");
    20.  
    21. //添加重复元素
    22.  
    23. list.add("hello");
    24.  
    25. list.add("陕科大");
    26.  
    27. System.out.println(list);
    28.  
    29. //返回集合中元素的个数
    30.  
    31. System.out.println("新增元素后集合长度："+list.size());
    32.  
    33. //判断集合是否为空
    34.  
    35. System.out.println("集合是否为空："+list.isEmpty());
    36.  
    37. //判断集合是否包含指定元素(元素存在)
    38.  
    39. System.out.println("集合中是否包含元素“hello”:"+list.contains("hello"));
    40.  
    41. //判断集合是否包含指定元素(元素不存在)
    42.  
    43. System.out.println("集合中是否包含元素“haha”:"+list.contains("haha"));
    44.  
    45. //取得集合指定位置的元素
    46.  
    47. System.out.println("下标为2的元素："+list.get(2));
    48.  
    49. //修改指定位置的元素
    50.  
    51. System.out.println("修改下标为3的元素：");
    52.  
    53. list.set(3, "lemon");
    54.  
    55. System.out.println("修改元素后将集合中元素转化为数组并打印"+list.toArray());
    56.  
    57. for (String string : list) {
    58.  
    59. System.out.print(" "+string);
    60.  
    61. }
    62.  
    63. System.out.println();
    64.  
    65. //清空集合中元素
    66.  
    67. System.out.println("清空集合：");
    68.  
    69. list.clear();
    70.  
    71. System.out.println("清空后集合是否为空："+list.isEmpty());
    72.  
    73.  }
    74.  
    75. }

                        

    由上述运行结果我们可以发现List可以存储重复元素。

    get()方法是List子接口提供的，根据指定下标返回元素。若我们要对Collection接口实现此操作，则引用该将其转换为对象数组再进行操作。

    1. //利用Collection实现get()方法
    2.  
    3. public class Test {
    4.  
    5. public static void main(String[] args) {
    6.  
    7. //这时候集合中只能存String类型的数据
    8.  
    9. Collection<String> list = new ArrayList<>();
    10.  
    11. list.add("hello");
    12.  
    13. list.add("world");
    14.  
    15. //添加重复元素
    16.  
    17. list.add("hello");
    18.  
    19. list.add("陕科大");
    20.  
    21. //操作以Object为主，可能需要向下转型，就会出现ClassCastException异常
    22.  
    23. Object[] object = list.toArray();
    24.  
    25. System.out.println(Arrays.toString(object));
    26.  
    27. System.out.println("下标为2的元素:"+object[2]);
    28.  
    29.  }
    30.  
    31. }

                              

    （1）Vector

    Vector是jdk1.0提出的，而ArrayList是jdk1.2提出的，Vector相对使用较少。

    Vector的使用与ArrayList的使用类似

    1. public class Test {
    2.  
    3. public static void main(String[] args) {
    4.  
    5. //这时候集合中只能存String类型的数据
    6.  
    7. List<String> list = new Vector<>();
    8.  
    9. list.add("hello");
    10.  
    11. list.add("world");
    12.  
    13. //添加重复元素
    14.  
    15. list.add("hello");
    16.  
    17. System.out.println(list);
    18.  
    19. //返回集合中元素的个数
    20.  
    21. System.out.println("新增元素后集合长度："+list.size());
    22.  
    23. //判断集合是否为空
    24.  
    25. System.out.println("集合是否为空："+list.isEmpty());
    26.  
    27. //判断集合是否包含指定元素(元素存在)
    28.  
    29. System.out.println("集合中是否包含元素“hello”:"+list.contains("hello"));
    30.  
    31. //判断集合是否包含指定元素(元素不存在)
    32.  
    33. System.out.println("集合中是否包含元素“haha”:"+list.contains("haha"));
    34.  
    35. //取得集合指定位置的元素
    36.  
    37. System.out.println("下标为2的元素："+list.get(2));
    38.  
    39. //修改指定位置的元素
    40.  
    41. System.out.println("修改下标为3的元素：");
    42.  
    43. list.set(1, "lemon");
    44.  
    45. System.out.println("修改元素后将集合中元素转化为数组并打印"+list.toArray());
    46.  
    47. for (String string : list) {
    48.  
    49. System.out.print(" "+string);
    50.  
    51. }
    52.  
    53. System.out.println();
    54.  
    55. //清空集合中元素
    56.  
    57. System.out.println("清空集合：");
    58.  
    59. list.clear();
    60.  
    61. System.out.println("清空后集合是否为空："+list.isEmpty());
    62.  
    63.  }
    64.  
    65. }

    ArrayList和Vector的区别：

    A. 时间上：Vector是jdk1.0提供的；而ArrayList是jdk1.5提供的。

    B. 处理形式：Vector是同步处理，性能较低；而ArrayList是异步处理，性能相对高。

    C. 数据安全：Vector是线程安全的；而ArrayList是非线程安全的。

    D. 输出形式：Vector支持Iterator、ListIterator、 foreach、Enumeration输出；而ArrayList支持Iterator、ListIterator、foreach输出。

    （2）LinkedList

    若还是利用子类向父类转型来使用的话，LinkedList的使用和前面两者也没什么区别。

    ArrayList和LinkedList的区别：

    观察ArrayList的源码，可以发现ArrayList里面存放的是一个数组，如果实例化此对象时传入了数组的大小，则里面保存的数组就会开辟一个定长的数组，但是后续中再进行数据保存，若该长度不够使用则会对数组进行动态扩充。所以我们在使用ArrayList时最好对其设置初始化大小。

    LinkedList就是一个纯粹的链表实现，除性能高外与我们编写的链表没有什么区别。

    ArrayList封装的是数组，而LinkedList封装的是链表。进行查找时ArrayList的时间复杂度为1，而LinkedList的时间复杂度为n。

    3、Set接口

    与List接口相比Set：Set中的内容是不允许重复的，且没有对Collection接口再进行方法的扩充。所以Set中没有get()方法。

    Set接口中提供与两个常用子类：HashSet（无需存储）和TreeSet（有序存储）。

                           

    1. public class Test{
    2. 	public static void main(String[] args) {
    3. //Set<Integer> set = new HashSet<>();
    4. 		Set<Integer> set = new TreeSet<>();
    5. 		set.add(20);
    6. 		set.add(6);
    7. 		set.add(15);
    8. 		set.add(-3);
    9. 		set.add(20);
    10. 		//添加重复元素
    11. 		System.out.println(set);
    12. 	}
    13. }

    HashSet运行后结果                TreeSet运行后结果

                                          

    由此我们可以看出HashSet是对集合进行无需存储，而TreeSet则对集合进行有序存储（采用升序模式进行排列）。

    （1）TreeSet中排序的分析

    因此我们对TreeSet的排序来进行分析：

        由于TreeSet可以进行排序操作，所以我们可以来实现数据的排序处理。此时进行的排序实际是针对对象数组进行的排序处理，而如果要对对象数组进行排序，则对象所在的类要实现Comparable接口并且要覆写compareTo()方法(要利用Comparable接口进行大小关系比较时必须要对所有的属性进行比较操作)。


    1. //自定义类
    2. class Person implements Comparable<Person>{
    3. 	private String name;
    4. 	private Integer age;
    5. 	@Override
    6. 	public String toString() {
    7. 		return "Person [name=" + name + ", age=" + age + "]";
    8. 	}
    9. 	Person(String name, Integer age) {
    10. 		super();
    11. 		this.name = name;
    12. 		this.age = age;
    13. 	}
    14. 	public String getName() {
    15. 		return name;
    16. 	}
    17. 	public void setName(String name) {
    18. 		this.name = name;
    19. 	}
    20. 	public Integer getAge() {
    21. 		return age;
    22. 	}
    23. 	public void setAge(Integer age) {
    24. 		this.age = age;
    25. 	}
    26. 	@Override
    27. 	public int compareTo(Person o) {
    28. 		if(this.age > o.age) {
    29. 			return 1;
    30. 		}else if(this.age < o.age) {
    31. 			return -1;
    32. 		}else {
    33. 			return this.name.compareTo(o.name);
    34. 		}
    35. 	}
    36. }
    37. public class Test{
    38. 	public static void main(String[] args) {
    39. 		Set<Person> set = new TreeSet<>();
    40. 		set.add(new Person("lemon",20));
    41. 		set.add(new Person("demon", 20));
    42. 		set.add(new Person("lemon",20));
    43. 		System.out.println(set);
    44. 	}
    45. }

    这样一个一个属性进行比较的操作过于麻烦，所以一般情况下我们都使用HashSet。

    （2）重复元素的判断在使用TreeSet子类进行数据保存时。重复元素的判断依靠Comparable接口来实现。但是这并不是全部Set接口判断元素重复的方式，因为如果使用的是HashSet子类，因为其和Comparable没有任何关系，所以它判断重复要依靠Object类的两个方法：

    hash码： public native int hashCode();

    对象比较：public boolean equals(Object obj);

    在Java中进行对象比较的操作有两个步骤：第一步要通过一个对象的唯一编码找到一个对象的信息，当编码匹配之后再进行下一步操作利用equals()方法进行内容比较。

    1. /*
    2.  * 标识对象的唯一性
    3.  * */
    4. //自定义类
    5. class Person implements Comparable<Person>{
    6. 	private String name;
    7. 	private Integer age;
    8. 	@Override
    9. 	public String toString() {
    10. 		return "Person [name=" + name + ", age=" + age + "]";
    11. 	}
    12. 	Person(String name, Integer age) {
    13. 		super();
    14. 		this.name = name;
    15. 		this.age = age;
    16. 	}
    17. 	public String getName() {
    18. 		return name;
    19. 	}
    20. 	public void setName(String name) {
    21. 		this.name = name;
    22. 	}
    23. 	public Integer getAge() {
    24. 		return age;
    25. 	}
    26. 	public void setAge(Integer age) {
    27. 		this.age = age;
    28. 	}
    29. 	
    30. 	public int compareTo(Person o) {
    31. 		if(this.age > o.age) {
    32. 			return 1;
    33. 		}else if(this.age < o.age) {
    34. 			return -1;
    35. 		}else {
    36. 			return this.name.compareTo(o.name);
    37. 		}
    38. 	}
    39. 	@Override
    40. 	public int hashCode() {
    41. 		return Objects.hash(name,age);
    42. 	}
    43. 	@Override
    44. 	public boolean equals(Object obj) {
    45. 		if(this == obj) {
    46. 			return true;
    47. 		}
    48. 		if(obj == null|| getClass()!=obj.getClass()) {
    49. 			return false;
    50. 		}
    51. 		Person person = (Person) obj;
    52. 		return Objects.equals(name,person.name)
    53. 				&& Objects.equals(age,person.age);
    54. 	}
    55. 	
    56. }
    57. public class Test{
    58. 	public static void main(String[] args) {
    59. 		Set<Person> set = new HashSet<>();
    60. 		set.add(new Person("lemon",20));
    61. 		set.add(new Person("lemon",20));
    62. 		set.add(new Person("demon", 18));
    63. 		System.out.println(set);
    64. 	}
    65. }

    不覆写hashCode()和equals()方法或只覆写一个运行结果：


    两个方法覆写后运行结果：

    所以想要标识出对象的唯一性,则必须覆写hashCode()和equals()两个方法。

    如果两个对象的hashCode()相同,equals()不同；或两个对象的equals()相同，而hashCode()不同时，这两个对象都是不能消除。而只有当两个对象的hashCode()和equals()都相同时，这两个对象才能判定为同一对象，即相同。

    所以在保存自定义类信息时，建议使用List接口。而保存系统类信息时，建议使用Set接口。
  • 相关阅读:
    【转载】SAP_ECC6.0_EHP4或SAP_ECC6.0_EHP5_基于Windows_Server_2008R2_和SQL_server_2008下的安装
    使用delphi 开发多层应用（二十四）KbmMW 的消息方式和创建WIB节点
    使用delphi 开发多层应用（二十三）KbmMW 的WIB
    实现KbmMw web server 支持https
    KbmMW 服务器架构简介
    Devexpress VCL Build v2014 vol 14.1.1 beta发布
    使用delphi 开发多层应用（二十二）使用kbmMW 的认证管理器
    KbmMW 4.50.00 测试版发布
    Basic4android v3.80 beta 发布
    KbmMW 认证管理器说明(转载)
  • 原文地址：https://www.cnblogs.com/edda/p/12600249.html
Copyright © 2011-2022 走看看