Java之集合初探(一)

一、集合概述、区别

集合是一种容器,数组也是一种容器

在Java编程中,装各种各样的对象(引用类型)的叫做容器。

为什么出现集合类?

面向对象语言对事物的体现都是以对象的形式,所以为了方便对多个对象的操作,Java就提供了集合类。

数组和集合类同是容器,有何不同?

A:长度区别   数组的长度固定   集合长度可变 B:内容不同   数组存储的是同一种类型的元素   而集合可以存储不同类型的元素 C:元素的数据类型问题   数组可以存储基本数据类型,也可以存储引用数据类型   集合只能存储引用类型

集合类的特点

集合只用于存储对象,集合长度是可变的,集合可以存储不同类型的对象。

如果我们用数组来制作一个简单的容器,可以存储数据改变大小

//自定义的容器

package util;

import java.lang.reflect.Array;
import java.util.Arrays;

public class Myarr {
    private Object[] obj;
    private int size;//代表数组中有效的数量
    
    public Myarr(){
        obj=new Object[10];
        size=0;
    }
    
    public int Size(){
        return this.size;
    }
    
    public boolean add(Object o){//可以添加各种类型
        //因为数组的长度是固定的,首先判断装满否
        
        if(size<obj.length){//有效长度小于数组长度,没装满
            obj[size]=o;
        }else{
            Object[] os=Arrays.copyOf(obj, size+1);
            os[size]=o;
            obj=os;
        }
        size++;
        if(size==obj.length){
            return true;
        }
        return false;
    }
    
    public String toString(){
        Object[] onew=new Object[size];
        for(int i=0;i<size;i++){
            onew[i]=obj[i];
        }
        return Arrays.toString(onew);
    }
}
//主方法
package test;

import util.Myarr;

public class Test {
    public static void main(String[] args) {
                // 添加小于10的情况
        Myarr ma=new Myarr();
        ma.add(56);
        ma.add("so");
        ma.add(5.653);
        System.out.println(ma.Size());
        System.out.println(ma);
                //添加大于10的情况
        Myarr ma1=new Myarr();
        ma1.add(56);
        ma1.add("so");
        ma1.add(5.653);
        ma1.add(56);
        ma1.add("so");
        ma1.add(5.653);
        ma1.add(56);
        ma1.add("so");
        ma1.add(5.653);
        ma1.add(56);
        ma1.add("so");
        ma1.add(5.653);
        System.out.println(ma1.Size());
        System.out.println(ma1);
    }
}

二、不同的集合类

集合是存储多个元的,由于存储多个元素我们也是有不同需求的:比如,我要这多个元素中不能有相同的元素,再比如,我要这多个元素按照某种规则排序一下。针对不同的需求,Java就提供了不同的集合类。 这多个集合类的数据结构不同,结构不同不重要的,重要的是你要能够存储东西,并且还要能够使用这些东西,比如说判断,获取等。 既然这样,那么,这多个集合类是有共性的内容的,我们把这些集合类的共性内容不断的向上提取,最终就能形成集合的继承体系结构

Collection:是集合的顶层接口,它的子体系有重复的,有唯一的,有有序的,有无序的。

Collection   List---(有顺序, 可以重复)---下标

    (这里判断重复的标准是可以互相equals(引用类型))

    LinkedList(基于链表)---(改快,查慢)

    *ArrayList(基于数组)---(改慢,查快)

  Set---(没有顺序, 不可以重复)

    *HashSet(基于hash码表)(必须重写hashCode()方法)

    TreeSet(基于二叉树---数据结构)

Map(以键值对的方式存在)(键不能重复)

  Map<Person.hashCode(), int>

  *HashMap

  TreeMap

Comparable(一个方法(comparaTo))

Iterator(循环遍历, 3个方法)

  返回值boolean hasNext()集合里有没有下一个

  返回值Object next()返回下一个对象的实例

  remove() 

  大致如下

  while(hasNext()) {     next()   }

 注意:

接口不可以直接new实例化,new后面只能是他的子类,Collection里没有方法体

Collection的功能概述:

1:添加功能 boolean add(Object obj):添加一个元素 boolean addAll(Collection c):添加一个集合的元素 2:删除功能 void clear():移除所有元素 boolean remove(Object o):移除一个元素 boolean removeAll(Collection c):移除一个集合的元素(是一个还是所有) 3:判断功能 boolean contains(Object o):判断集合中是否包含指定的元素 boolean containsAll(Collection c):判断集合中是否包含指定的集合元素(是一个还是所有) boolean isEmpty():判断集合是否为空 4:获取功能 Iterator<E> iterator()(重点) 5:长度功能 int size():元素的个数 面试题:数组有没有length()方法呢?字符串有没有length()方法呢?集合有没有length()方法呢? 6:交集功能 boolean retainAll(Collection c):两个集合都有的元素?思考元素去哪了,返回的boolean又是什么意思呢? 7:把集合转换为数组 Object[] toArray()

Java中集合主要分为三类

  • Set(集)
  • List(列表)
  • Map(映射)

List接口(列表):

List的特征是其元素以线性方式存储,集合中可以存放重复对象。 

List接口主要实现类包括:

  • ArrayList() : 代表长度可以改变得数组。可以对元素进行随机的访问,向ArrayList()中插入与删除元素的速度慢。 API中介绍初始容量为10。
  • LinkedList(): 在实现中采用链表数据结构。插入和删除速度快,访问速度慢。 

对于List的随机访问来说,就是只随机来检索位于特定位置的元素。 List 的 get(int index) 方法放回集合中由参数index指定的索引位置的对象,下标从“0” 开始。最基本的两种检索集合中的所有对象的方法: 

  1: for循环和get()方法: 

  2: 使用 迭代器(Iterator): 

List主要分:

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

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

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

接口的常用方法

add()   添加

remove()    移除

import java.util.ArrayList;
import java.util.Collection;
public class TestColle {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Collection c=new ArrayList();
        c.add(1);
        c.add("hello");
        c.add(new Person());
        System.out.println(c);
        
        c.remove(1);
        c.remove("hello");
        c.remove(new Person());//用new新创建的equls时找不到原来的new 创建的所以移除不了
        System.out.println(c.size());
        System.out.println(c);
    }
}
class Person{
    @Override
    public String toString() {
        return "Person [hi]";
    }
}

List接口其他常用方法

 1 package until;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 
 6 public class Test1 {
 7     public static void main(String[] args) {
 8         List li=new ArrayList();
 9         List lis=new ArrayList();
10         
11         for(int i=0;i<5;i++){
12             li.add("string"+i);
13             if(i%2==0){
14                 lis.add("string"+i);
15             }
16         }
17         System.out.println(li);
18         System.out.println(li.get(2));//获取该索引位置的值
19         System.out.println(li.set(1, "Hello"));//将某个索引的值设置为另一个对象,然后将原来的索引的值返回
20         System.out.println(li);
21         System.out.println(li.remove(4));//删除对象并将删除的对象返回
22         System.out.println(li.indexOf("string0"));//返回该对象第一次出现的位置
23         System.out.println(li.lastIndexOf("string0"));//返回该对象最后一次出现的位置
24         System.out.println(li.retainAll(lis));//取二者的交集赋给第一个集合,如果两个第一个集合改变了返回true
25         System.out.println(li);
26     }
27 }

Map(映射):

Map 是一种把键对象和值对象映射的集合,它的每一个元素都包含一对键对象和值对象。 Map没有继承于Collection接口 从Map集合中检索元素时,只要给出键对象,就会返回对应的值对象。 

Map的执行效率相对低下。 

Map包含:

Map : 维护“键值对”的关联性,使你可以通过“键”查找“值”

HashMap:Map基于散列表的实现。插入和查询“键值对”的开销是固定的。可以通过构造器设置容量capacity和负载因子load factor,以调整容器的性能。 

LinkedHashMap: 类似于HashMap,但是迭代遍历它时,取得“键值对”的顺序是其插入次序,或者是最近最少使用(LRU)的次序。只比HashMap慢一点。而在迭代访问时发而更快,因为它使用链表维护内部次序。 

TreeMap : 基于红黑树数据结构的实现。查看“键”或“键值对”时,它们会被排序(次序由Comparabel或Comparator决定)。TreeMap的特点在 于,你得到的结果是经过排序的。TreeMap是唯一的带有subMap()方法的Map,它可以返回一个子树。 

WeakHashMao :弱键(weak key)Map,Map中使用的对象也被允许释放: 这是为解决特殊问题设计的。如果没有map之外的引用指向某个“键”,则此“键”可以被垃圾收集器回收。 

IdentifyHashMap: : 使用==代替equals()对“键”作比较的hash map。专为解决特殊问题而设计。

Map接口常用方法

package until;
import java.util.HashMap;
import java.util.Map;

public class Test1 {
    public static void main(String[] args) {
        Map map = new HashMap();
        for (int i = 0; i < 5; i++) {
            map.put(i, new Person("name" + i));//循环添加
        }
        System.out.println(map);
        map.put(5, new Person("Xman"));//再次添加
        System.out.println(map);
        map.put(1, new Person("NewMan"));//在已有的键上添加替换
        System.out.println(map);
        System.out.println(map.get(5));//获取指定的键的值
        System.out.println(map.remove(0));//删除键的值并返回值
        System.out.println(map.remove(0, "na"));//删除键值,成功返回true
        System.out.println(map.containsKey(4));//判断是否包含该键
        System.out.println(map.containsValue(new Person("name0")));//判断是否有该值
        System.out.println(map.size());//返回有多少对
        System.out.println(map.isEmpty());//返回是否空
        map.clear();//清空
        System.out.println(map);
        Map map2=new HashMap();
        map2.putAll(map);//添加另一个map集合
        System.out.println(map2);
    }
}

class Person{
    String name;
    public Person(String name) {
        this.name = name;
    }
    
    @Override
    public String toString() {
        return "P ["+ name + "]";
    }
}

Set接口

Set是最简单的一种集合。集合中的对象不按特定的方式排序,并且没有重复对象。 Set接口主要实现了两个实现类:

  HashSet: HashSet类按照哈希算法来存取集合中的对象,存取速度比较快 

  TreeSet :TreeSet类实现了SortedSet接口,能够对集合中的对象进行排序。 

Set具有与Collection完全一样的接口,因此没有任何额外的功能。(这是继承与多态思想的典型应用:表现不同的行为。)Set不保存重复的元素。 存入Set的每个元素都必须是唯一的,因为Set不保存重复元素。加入Set的元素必须定义equals()方法以确保对象的唯一性。Set与Collection有完全一样的接口。Set接口不保证维护元素的次序。 

 HashSet:为快速查找设计的Set。存入HashSet的对象必须定义hashCode()。 

TreeSet: 保存次序的Set, 底层为树结构。使用它可以从Set中提取有序的序列。 

LinkedHashSet:具有HashSet的查询速度,且内部使用链表维护元素的顺序(插入的次序)。于是在使用迭代器遍历Set时,结果会按元素插入的次序显示。

三、总结与注意

Collection 和 Map 的区别

容器内每个为之所存储的元素个数不同。

Collection类型者,每个位置只有一个元素。

Map类型者,键值对,类似于数据库。

注意:

1.Collection、List、Set、Map都是接口,不能实例化。继承自它们的 ArrayList, Vector, HashTable, HashMap是具象class,这些才可被实例化。

2. 如果涉及到堆栈,队列等操作,应该考虑用List,对于需要快速插入,删除元素,应该使用LinkedList,如果需要快速随机访问元素,应该使用ArrayList。

3. 在除需要排序时使用TreeSet,TreeMap外,都应使用HashSet,HashMap,因为他们 的效率更高。

4. 容器类仅能持有对象引用(指向对象的指针),而不是将对象信息copy一份至数列某位置。一旦将对象置入容器内,便损失了该对象的型别信息。

5. 尽量返回接口而非实际的类型,如返回List而非ArrayList,这样如果以后需要将ArrayList换成LinkedList时,客户端代码不用改变。这就是针对抽象编程。

6、Collection没有get()方法来取得某个元素。只能通过iterator()遍历元素。

7、List,可以通过get()方法来一次取出一个元素。使用数字来选择一堆对象中的一个,get(0)...。(add/get)

8、Map用 put(k,v) / get(k),还可以使用containsKey()/containsValue()来检查其中是否含有某个key/value。HashMap会利用对象的hashCode来快速找到key。

9、Map中元素,可以将key序列、value序列单独抽取出来。

使用keySet()抽取key序列,将map中的所有keys生成一个Set。

使用values()抽取value序列,将map中的所有values生成一个Collection。

因为,key总是独一无二的,value允许重复。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏Ryan Miao

java中List对象列表去重或取出以及排序

面试碰到几次list的去重和排序。下面介绍一种做法: 1. list去重 1.1 实体类Student List<Student>容量10k以上,要求去重复。这...

8129
来自专栏Phoenix的Android之旅

Java面试的基础中的基础

面试时经常从Java的基础知识开始,最基础的部分莫过于Java的集合类型。我们知道Java的集合类型有三种,Set,List,Map,那这三种有什么区别呢。

1011
来自专栏郭耀华‘s Blog

剑指offer第五天

28.数组中出现次数超过一半的数字 数组中有一个数字出现的次数超过数组长度的一半,请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2...

2755
来自专栏和蔼的张星的图像处理专栏

76. 最长上升子序列动态规划+二分查找

给定一个整数序列,找到最长上升子序列(LIS),返回LIS的长度。 说明 最长上升子序列的定义: 最长上升子序列问题是在一个无序的给定序列中找到一个尽可能...

6331
来自专栏LinkedBear的个人空间

唠唠SE的集合-02——Iterator迭代器

迭代时如果没有先执行next()则会抛出IllegalStateException,这就意味着必须要先检查是否还有下一个可以被迭代的元素,才能往外取。

1043
来自专栏文武兼修ing——机器学习与IC设计

抽象数据结构与表抽象数据结构表

抽象数据结构 抽象数据结构(ADT)是一些操作的集合,集合了一些必要且重用性高的操作,这些操作在一个项目中只被编写一次。抽象数据结构只定义操作的存在,并不定义操...

2976
来自专栏编程

Python基础1

数据类型 Python3中有6钟标准的数据类型:Number(数字)、String(字符 串)、List(列表)、Tuple(元组)、Sets(集合)、Dict...

23010
来自专栏鸿的学习笔记

Python和Scala的集合和映射

在入门系列的最后,让我们来看看基于hash表的两种常见的数据结构,集合和映射。在Scala里的集合和映射,这两种数据结构都有可变和不可变的两种版本,区别仅仅在于...

692
来自专栏深度学习与计算机视觉

算法-数字在排序数组中出现的次数

题目: 统计一个数字在排序数组中出现的次数,比如排序数组为{1,2,3,3,3,4,5},那么数字3出现的次数就是3。 解题思路: 1.首先,遍历数组肯...

2105
来自专栏一个会写诗的程序员的博客

第7章 集合类第7章 集合类

在 Java 类库中有一套相当完整的容器集合类来持有对象。Kotlin没有去重复造轮子(Scala则是自己实现了一套集合类框架),而是在Java 类库的基础上进...

822

扫码关注云+社区

领取腾讯云代金券