万年历的凌晨曙光：集合讲解

转x33g5p2x  于2021-11-22 转载在 其他  
字(6.2k)|赞(0)|评价(0)|浏览(311)

首先想到了ArrayList和List的区别：

1： List是一个接口，而ArrayList是List接口的一个实现类。

2：List接口不能被构造，也就是我们说的不能创建实例对象，但是我们可以像下面那样为List接口创建一个指向自己的对象引用，而ArrayList实现类的实例对象就在这充当了这个指向List接口的对象引用。

又想到了集合和数组的区别：

数组：这是java语言内置的数据类型，是一个线性序列，可以快速的访问其他元素，数据在你创建的那一刻就已经定好了容量，并且生命周期也是不能改变的，并且再java的异常机制中发现了数组越界会报错：RuntimeException

集合：java对于集合提供了三种集合：list，map，set，这些对象直接归根于object,他们处理对象的时候就好像这些对象没有自己的类型一样,这样只需要创建一个集合，把对象放进去，取出时转换成自己的类型就行了。

数组和集合的区别

  • 1、数组声明了它容纳的元素的类型，而集合不声明。

  • 2、数组的长度是固定的，集合长度是可以改变的。

数组是静态的，一个数组实例具有固定的大小，一旦创建了就无法改变容量了。而集合是可以动态扩展容量，可以根据需要动态改变大小，集合提供更多的成员方法，能满足更多的需求。

  • 3、数组的存放的类型只能是一种（基本类型/引用类型），集合存放的类型可以不是一种(不加泛型时添加的类型是Object)。

  • 4、数组是java语言中内置的数据类型,是线性排列的,执行效率或者类型检查都是最快的。

  • 5、集合以接口和类的形式存在，具有封装，继承和多态等类的特性，通过简单的方法和属性调用即可实现各种复杂的操作，大大提高软件的开发效率。

  1. List list;//正确，list = null; 
  3.        List list = new List();//是错误的用法 这是错误的！！！！！
  5.        List list = new ArrayList();这句创建了一个ArrayList实现类的对象后把它上溯到了List接口。此时它就是一个List对
  7. 象了，它有些ArrayList类具有的，但是List接口没有的属性和方法，它就不能再用了。 而ArrayList list=newArrayList();
  9. 创建一对象则保留了ArrayList的所有属性和方法。

list，map，set的讲解：

Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│　└Stack
└Set
Map
├Hashtable
├HashMap
└WeakHashMap

首先通过这张图就可以看出来在Collection中包含了List和Set，Map是单独列出来的一个

然后是Collection：这是在用到ArrayList的时候发现有一个求最大的集合中的值用到了Collection，这里再讲解一下Collection接口：

1：Collection接口

Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）。Java SDK不提供直接继承自Collection的类，Java SDK提供的类都是继承自Collection的“子接口”如List和Set。
　　所有实现Collection接口的类都必须提供两个标准的构造函数：无参数的构造函数用于创建一个空的Collection，有一个 Collection参数的构造函数用于创建一个新的Collection，这个新的Collection与传入的Collection有相同的元素。后一个构造函数允许用户复制一个Collection。
　　如何遍历Collection中的每一个元素？不论Collection的实际类型如何，它都支持一个iterator()的方法，该方法返回一个迭代子，使用该迭代子即可逐一访问Collection中每一个元素。典型的用法如下：

  1. Iterator it = collection.iterator(); // 获得一个迭代子
  2. while(it.hasNext()) {
  3. 　　Object obj = it.next(); // 得到下一个元素
  4. }　

由Collection接口派生的两个接口是List和Set。

2.Set：不包含重复的元素！

Set接口同样是Collection接口的一个子接口，它表示数学意义上的集合概念。Set中不包含重复的元素，即Set中不存两个这样的元素e1和e2，使得e1.equals(e2)为true。由于Set接口提供的数据结构是数学意义上集合概念的抽象，因此它需要支持对象的添加、删除，而不需提供随机访问。故Set接口与Collection的接口相同。

  • 1：Set接口继承Collection接口，而且它不允许集合中存在重复项。所有原始方法都是现成的，没有引入新方法。具体的Set实现类依赖添加的对象的equals()方法来检查等同性。

  • 2：HashSet： 使用HashMap的一个集的实现。虽然集定义成无序，但必须存在某种方法能相当高效地找到一个对象。使用一个HashMap对象实现集的存储和检索操作是在固定时间内实现的.

  • 3：TreeSet： 在集中以升序对对象排序的集的实现。这意味着从一个TreeSet对象获得第一个迭代器将按升序提供对象。TreeSet类使用了一个TreeMap.

Set的演示：

  1. import java.util.*;
  2. public class SetExample {
  3.       public static void main(String args[]) {
  4.           Set set = new HashSet();
  5.           set.add("Bernadine");
  6.           set.add("Elizabeth");
  7.           set.add("Gene");
  8.           set.add("Elizabeth");
  9.           set.add("Clara");
  10.           System.out.println(set);
  12.           Set sortedSet = new TreeSet(set);
  13.           System.out.println(sortedSet);
  14.       }
  15. }
  19. 运行程序产生了以下输出。请注意重复的条目只出现了一次，列表的第二次输出已按字母顺序排序。
  20. [Gene, Clara, Bernadine, Elizabeth]
  21. [Bernadine, Clara, Elizabeth, Gene]

3.List：

1：List接口继承了Collection 接口以定义一个允许重复项的有序集合。该接口不但能够对列表的一部分进行处理，还添加了面向位置的操作。

2： 实际上有两种List: 一种是基本的ArrayList,其优点在于随机访问元素，另一种是更强大的LinkedList,它并不是为快速随机访问设计的，而是具有一套更通用的方法。

3：List : 次序是List最重要的特点：它保证维护元素特定的顺序。List为Collection添加了许多方法，使得能够向List中间插入与移除元素(这只推荐LinkedList使用。)一个List可以生成ListIterator,使用它可以从两个方向遍历List,也可以从List中间插入和移除元素。

4：ArrayList : 由数组实现的List。允许对元素进行快速随机访问，但是向List中间插入与移除元素的速度很慢。ListIterator只应该用来由后向前遍历ArrayList,而不是用来插入和移除元素。因为那比LinkedList开销要大很多。

5：LinkedList : 对顺序访问进行了优化，向List中间插入与删除的开销并不大，随机访问则相对较慢。(使用ArrayList代替。)还具有下列方法：addFirst(), addLast(), getFirst(), getLast(), removeFirst() 和 removeLast(), 这些方法 (没有在任何接口或基类中定义过)使得LinkedList可以当作堆栈、队列和双向队列使用。

6：　Vector：实现一个类似数组一样的表，自动增加容量来容纳你所需的元素。使用下标存储和检索对象就象在一个标准的数组中一样。你也可以用一个迭代器从一个Vector中检索对象。Vector是唯一的同步容器类!!当两个或多个线程同时访问时也是性能良好的。

7：Stsck: 这个类从Vector派生而来，并且增加了方法实现栈!一种后进先出的存储结构。

4.List和Set对比：

用到了ArrayList＜Integer＞中的一些方法：

1.添加元素：

  1. //添加
  2. ArrayList<Integer> list2 = new ArrayList<Integer>();
  3. list2.add(12);
  4. list2.add(23);
  5. list2.add(9);

2：最大最小值

  1. // get max,min
  2. int maxa = Collections.max(list2),mina = Collections.min(list2);
  3. System.out.println("list2's max value is " + maxa);
  4. System.out.println("list2's min value is " + mina);
  8. list2's max value is 23
  9. list2's min value is 9

3.输出

  1. //print 
  2. System.out.println("whole list2 is "+list2);
  4. whole list2 is [12, 23, 9]

4.拷贝：

  1. //拷贝
  2. ArrayList<Integer> list21 = new ArrayList<Integer>();
  3. list21.addAll(list2);
  4. System.out.println("list21:copy list2 is "+list21);//不变

5.从小到大排序

  1. Collections.sort(list2);
  2. System.out.println("list2 sort is "+list2);
  4. list2 sort is [9, 12, 23]

6.从大到小排序

  1. Collections.sort(list2,Collections.reverseOrder());
  2. System.out.println("list2 descend sort is "+list2);
  4. list2 descend sort is [23, 12, 9]

7.倒序

  1. Collections.reverse(list21);
  2. System.out.println("reverse list21 is "+list21);
  4. reverse list21 is [9, 23, 12]

8.求某个元素首次出现的位置

  1. int idx = list2.indexOf(23);
  2. System.out.println("list2 is "+list2+" and 23 locates :"+idx);
  4. list2 is [23, 12, 9] and 23 locates :0

9.求和

  1. int sum = 0;
  2. for (int i=0;i<list2.size();i++){
  3.     sum += list2.get(i);
  4. }
  5. System.out.println("list2 sum is "+sum);
  7. //利用stream求和
  8. List<Integer> ls = new ArrayList<Integer>();
  9. ls.add(43);
  10. ls.add(27);
  11. int sum2 = ls.stream().mapToInt(a->a).sum();
  12. System.out.println("sum is "+sum2);
  14. list2 sum is 44
  15. sum is 70

10.在指定位置插入元素

  1. //在1位置插入一个88(like insert)
  2. list2.add(1,88);
  3. System.out.println("insert 88 at [1] and list2 is "+list2);
  5. insert 88 at [1] and list2 is [23, 88, 12, 9]

11.移除某个位置的元素

  1. list2.remove(1);
  2. System.out.println("remove [1] and list2 is "+list2);
  3. list2.remove(list2.size()-1);//删除末尾
  4. System.out.println("remove the last and list2 is "+list2);
  6. remove [1] and list2 is [23, 12, 9]
  7. remove the last and list2 is [23, 12]

12.移除某个值：

  1. list2.add(0,23);
  2. System.out.println("add 23 at [0] and list2 now is "+list2);
  3. for (int i=0;i<list2.size();i++){
  4.     if (list2.get(i)==23){
  5.         list2.remove(i);
  6.         i--;
  7.     }
  8. }
  9. System.out.println("remove 23 and list2 is "+list2);
  11. remove 23 and list2 is [12]

13.切片

  1. ArrayList<Integer> list3 = new ArrayList<Integer>();
  2. list3.add(45);
  3. list3.add(52);
  4. list3.add(66);
  5. System.out.println("list3 is "+list3);
  6. System.out.println("list3[0:2] is "+list3.subList(0,2));
  8. list3 is [45, 52, 66]
  9. list3[0:2] is [45, 52]

14.转化为整形数组

  1. import java.util.*; 
  2. class Solution {
  3.     public int[] twoSum(int[] nums, int target) {
  4.         ArrayList<Integer> re = new ArrayList<Integer>();
  5.         for (int i=0;i<nums.length;i++){
  6.             for (int j=i+1;j<nums.length;j++){
  7.                 if (nums[i]+nums[j]==target){
  8.                     re.add(i);
  9.                     re.add(j);
  10.                 }
  11.             }
  12.         }
  13.         int[] res = re.stream().mapToInt(Integer::valueOf).toArray();
  14.         return res;
  15.     }
  16.     
  17.     
  18.     
  19.     // 调用
  20.     public static void main(String[] args){
  21.         int[] nums = {2,7,11,9};
  22.         int target = 9;
  23.         Solution s = new Solution();
  24.         int[] lst = s.twoSum(nums,target);
  25.         System.out.println(Arrays.toString(lst));
  26.     }
  27. }
  30. [0, 1]

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/justleavel/article/details/121416947

内容来源于网络，如有侵权，请联系作者删除！

mysqlDatabase数据库java学习

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多

    目录

    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com