java集合与包装类

Posted Transkai

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了java集合与包装类相关的知识,希望对你有一定的参考价值。

一.集合概述

1 为什么需要使用集合?
引入案例:存储每天产生的新闻。
是要解决数组的局限性(定长),由于数组定长,可能会导致内存浪费或者内存不够。
需要一种技术:能够根据数据量而动态伸缩内存空间一种技术。

与数组不同,没有长度限制
与数组不同,集合提供更多方便操作的方法
与数组不同,集合可以装不同类型的对象

2 什么是集合?
集合也叫容器,是用来装其它类型的对象元素的数据结构,有点类似数组
jdk提供一套容器框架,用来操作多个或者一组元素的容器
没有长度(元素个数)限制
集合提供一套各 种各样的api供我们选择,达到不同的操作目的
集合中的方法封装了一些算法,以便我们快速查找或者增删,或者排序。。。。
集合本身也是一个对象

 

二.如何研究集合?集合的API体系

 

 

除了上面的集合图之外,还需学习以下接口和工具类:
(1)比较排序接口
Comparable
Comparator
(2)遍历迭代接口
Iterable
Iterator
(3)工具类
Collections
Arrays


面试题:Collection和Collections区别

11个接口7个实现类2个工具类

Collection VS Map
Collection - 元素是一个一个对象


Map - 元素是一对对的,由key对象与value对象组成

 

 

三.Collection

1 概述
Collection分支的根接口

所有这个分支下面的实现都具有该接口中的方法

在某些场合,使用Collection具有更普遍的适应性
Collection coll = new ?();

public void fn(Collection coll){
//.....
}
fn(?);

2 方法介绍

 


add() - 添加一个元素
addAll() - 添加一组元素
clear() - 清空整个集合
contains() -判断 是否包含某个元素
containsAll() - 判断 是否包含一组元素
equals() - 比较一个集合与另一个集合是否相同,挨个比较集合中所有元素
hashCode() - 返回此集合的哈希码
isEmpty() - 是不是size为0,元素的个数是不是为0
iterator() - 获得此集合的迭代器,用来遍历集合
remove() - 删除指定的元素
removeAll() - 删除一组指定的元素
retainAll() - 当前集合与指定集合(参数)求交集
size() - 返回元素个数
toArray() - 将集合转为数组


 

 

四.List

1 概述
有序的可重复的 collection(也称为序列)。内部维护一个索引(下标)。
此接口的用户可以对列表中每个元素的插入位置进行精确地控制。
用户可以根据元素的整数索引(在列表中的位置)访问元素,并搜索列表中的元素
有序,就是插入顺序(位置)

2 示意图

 


3 List的操作
除了具有Collection的所有方法外,还提供通过下标来操作的方法


add(int index, E element) - 将某个元素添加到指定的下标处
addAll(int index, Collection<? extends E> c) - 将一组元素添加到指定的下标处
get(int index) - 通过下标来获得某个具体的元素
indexOf(Object o) -获得指定元素的下标,从集合的头开始找
lastIndexOf(Object o) - 获得指定元素的下标,集合的尾部开始找
listIterator() - 返回List的特有的迭代器(ListIterator),ListIterator功能比较强大
remove(int index) -通过下标来删除元素
set(int index, E element) - 替换指定下标位置的元素
subList(int fromIndex, int toIndex) - 通过下标截取子集


 


五.ArrayList和LinkedList

1 概述
List 接口存储一组不唯一(里面元素可重复),有序(插入顺序)的对象
ArrayList(顺序表)类实现了长度可变的数组,在内存中分配连续的空间。遍历元素和随机访问元素的效率比较高

 

LinkedList类采用链表存储方式。插入、删除元素时效率比较高

 

这2个类是List的实现类,但并不是直接实现

 

 

2 ArrayList 和LinkedList的相关操作


(1)public ArrayList(int initialCapacity)//创建集合时,给定初始容量,以避免多余的数组重建。

         int newCapacity = oldCapacity + (oldCapacity >> 1);

(2)public void ensureCapacity(int minCapacity)//给集合重新设置容量,以避免多余的数组重建。
(3)public void trimToSize() //ArrayList的尺寸是按照2的幂指数来增长的.比如你有17个元素,其实ArrayList是分了32空间,
   //其中有15个是空的? trimToSize就是把这15个给砍掉了...
(4)在List中有很多操作都要判断指定的元素是否在集合中,例如contains(Object o), remove(Object o),indexOf(Object o),
这些方法内部都使用eqauls()来比较是否相同

3 ArrayList 和 LinkedList的区别
(1)ArrayList-查找快,增删慢
底层用数组实现,数组本身有下标,通过下标查找特别快,但是增删的因为要移动元素,所以很慢
(2)LinkedList - 查找慢,增删快
底层用双向链表实现,本身没有下标,需要额外的维护下标索引,导致查找非常慢。但是因为使用链表,增删只改变一下引用,不需要移动元素就可以做到增删,所以特别快

 

 

六.ArrayList与Vector区别:

相同点:
回顾:StringBuffer(线程安全) 与 StringBuilder(线程不安全)
1.两者都实现了List接口(List接口继承了Collection接口)。
2.两者都是有序集合,即存储在这两个集合中的元素的位置都是有顺序的,相当于一种动态的数组。
3.存放的数据都允许重复。
不同点:
1.同步性:
Vector是线程安全的,也就是说是它的方法之间是线程同步的,适用于多线程访问集合,访问效率低。
ArrayList是线程序不安全的,它的方法之间是线程不同步的,适用于单线程访问集合,不考虑线程安全,访问效率高。
2.数据增长:
Vector默认增长原来的一倍,可以手工设置增长空间的大小。
ArrayList默认增加原来的0.5倍,不可以手工设置增长空间的大小。
newCapacity = oldCapacity + oldCapacity >>1;//相当于 oldCapacity + oldCapacity /2

七.Queue与Stack

1 概述
叫队列,这种数据结构有一种特点,先进先出(FIFO)
与Stack(栈)相对,栈是先进后出(FILO)

 


2 API方法
抛出异常 返回特殊值
插入 add(e) offer(e)
移除 remove() poll()
检查 element() peek()

八.LinkedList的队列的特点

public class TestQueue{
  public static void main(String[] args){
     //Queue q = new ArrayBlockingQueue(2);//有容量限制的队列
     
     Queue q = new LinkedList();
     /*
     q.add("haha");
     q.add("hehe");
     q.add("xixi");
     */
     q.offer("haha");
     q.offer("hehe");
     q.offer("xixi");
     
     /*
     System.out.println("==========1============>"+q);
     Object o1 = q.remove();
     System.out.println(o1+"==========2============>"+q);
     Object o2 = q.remove();
     System.out.println(o2+"==========3============>"+q);
     Object o3 = q.remove();
     System.out.println(o3+"==========4============>"+q);
     Object o4 = q.remove();
     */
     
     /*
     System.out.println("==========1============>"+q);
     Object o1 = q.poll();
     System.out.println(o1+"==========2============>"+q);
     Object o2 = q.poll();
     System.out.println(o2+"==========3============>"+q);
     Object o3 = q.poll();
     System.out.println(o3+"==========4============>"+q);
     Object o4 = q.poll();
     */
     
     /*
     System.out.println("==========1============>"+q);
     Object o1 = q.element();
     System.out.println(o1+"==========2============>"+q);
     q.clear();//清空队列
     Object o2 = q.element();
     System.out.println(o2+"==========2============>"+q);
     */
     
     System.out.println("==========1============>"+q);
     Object o1 = q.peek();
     System.out.println(o1+"==========2============>"+q);
     q.clear();//清空队列
     Object o2 = q.peek();
     System.out.println(o2+"==========2============>"+q);
  }
}

 

九.Set

1 Set概述
它是Collection子接口
特点是:无序的,不可重复
与List不同,Set没有下标

2 Set的API
全部方法都继承自Collection,没有自己扩展的方法

十.HashSet

(1)HashSet概述

是Set体系中比较常用的一个实现类
HashSet底层用的就是HashMap
HashMap是采用Hash算法的一种数据结构
Hash算法用快速寻找堆中的对象

(2)HashSet数据结构

 


构造方法
1)初始容量 - 也叫桶
2)加载因子 - 扩充容量用的
当桶数用完时,需要扩展当前容量*加载因子

3)HashSet的add方法的流程

 

 

(4)equals()和hashCode的约定

hashCode()是Object中的方法 ,该方法是根据对象的地址值通过某种算法算出来的值
如果对象不同,则hashCode()返回的值一定不同

但是,作为开发者,我们经常需要主观上认为2个不同的对象为同一个,比如说姓名和年龄相同就认为是同一个,此前我们是用equals()定制这个主观的认同规则

api中equals方法的约定;注意:当equals方法被重写时,通常有必要重写 hashCode 方法,以维护 hashCode 方法的常规协定,该协定声明相等对象必须具有相等的哈希码

api中hashCode的约定:equals中比较了哪些字段(属性),就用那些属性来生成hashCode就可以了

十一.Iterator

1 概述
迭代器,用于遍历集合,只要是实现了Collection接口,都一定具有iterator()方法,或者foreach方式遍历集合。该方法就是返回Iterator接口一个实例

2 Iterator操作

十二.LinkedHashSet

1 概述
Set接口下的一特例,它能够维持插入的顺序
此实现可以让客户免遭未指定的、由 HashSet 提供的通常杂乱无章的排序工作,而又不致引起与 TreeSet 关联的成本增加

2 LinkedHashSet操作
它的底层就是使用LinkedHashMap.

3 使用场合
如果我们的需求是元素不能重复,然后顺序是固定(插入顺序),此时就可以用LinkedHashSet

十三.排序树:TreeSet

1 概述
TreeSet底层就是使用TreeMap,它会按照自然顺序或比较器提供的顺序进行排序。
以二叉树的方式进行自然排序一个Set
Example:7, 5,2,4,12,13,8,15, 10,1
排序后:1 2 4 5 7 8 10 12 13 15
二叉树遍历方式:前序,中序,后序(递归算法)

 

 

如果要使用TreeSet,则添加到里面的元素必须实现Comparable接口
或者提供定制的Comparator接口的实现,提供这了Comparator接口的实现后可以不用再实现Comparable接口!!!

十四.Comparable

1 概述
叫做可比较接口
实现该接口,表示这个类的对象是可以排序的,这种排序被称为类的自然排序,接口中的 compareTo 方法被称为它的自然比较方法
实际就是我们的类可以实现这个接口来定制自己的排序比较规则,例如Person是按age来排序

2 API方法
//开发者可以实现该方法来定制比较规则
//如果该对象小于、等于或大于指定对象,则分别返回负整数、零或正整数
int compareTo(T o)

/**
重写定制自己的比较规则
先按年龄倒叙,如果年龄相等则按分数升序。
*/
public int compareTo(Object o) {
Student student = (Student) o;
if (this.age!=student.getAge()) {
return -(this.age-student.getAge());//按年龄倒叙
}else {
return this.score - student.getScore();//升序
}
}

 

十五.Comparator

1 概述
 比较器接口,可以让开发者更加精确和灵活的控制排序
 Collections.sort(Comparator)
 Arrays.sort(Comparator)
 TreeSet(Comparator)


2 API方法
/**
  比较器1 ,按年龄倒叙
*/
class MyComparator  implements Comparator<Student>{
  public int compare(Student o1, Student o2) {
     return -(o1.getAge()-o2.getAge());
  }
}
/**
  比较器2 ,按年龄倒叙,如果年龄相等,则按分数升序
*/
class MyComparator2  implements Comparator<Student>{
  public int compare(Student o1, Student o2) {
     if (o1.getAge()!=o2.getAge()) {
       return -(o1.getAge()-o2.getAge());
     }else {
       return o1.getScore()-o2.getScore();
     }
  }
}

 

 十六.Map

1 概述
映射,key - value
一个键(key) 决定一个值(value)
key不能重复,value可以重复
key没有顺序

2 Api方法
clear() - 清空Map
containsKey(Object key) - 是否包含指定的key
containsValue(Object value) - 是否包含指定的valie
entrySet() - 返回映射项(Map.Entry)组成的Set
equals(Object o) - 比较2个Map
get(Object key) - 通过key来获得value
hashCode() - 返回hash码
isEmpty() - 判断是否为空,其实就是判断 size==0
keySet() - 返回由key组成 的Set
put(K key, V value) - 将key和value添加到Map中
putAll(Map<? extends K,? extends V> m) - 将另一个Map中的所有key-value添加到本Map中
remove(Object key) -通过key来删除一对Entry
values() - 返回由所有的value组成的Collection
size() - 返回Map中的Entry的个数

十七.HashMap

1 概述
HashMap实现了Map接口
key也是跟HashSet一样,采用了哈希算法
HashSet底层用的就是HashMap

2 API操作

十八.HashMap和Hashtable区别:


1.同步性:
Hashtable是线程安全的,也就是说是它的方法之间是线程同步的,适用于多线程访问集合,访问效率低
HashMap是线程序不安全的,它的方法之间是线程不同步的,适用于单线程访问集合,不考虑线程安全,访问效率高。
2.值
只有HashMap可以让你将null值作为一个表的条目的key或value
Hashtable是不允许的,运行时抛NullPointerException
3.Hashtable是Dictionary的子类,HashMap是Map接口的一个实现类;

十九.LinkedHashMap

可以对照着LinkedHashSet来学习,它的底层就是使用LinkedHashMap.
可以维持key-value插入的顺序

二十.TreeMap

参照TreeSet来学习,TreeSet底层就是使用TreeMap,它会按照自然顺序或比较器提供的顺序进行排序。

默认按照key的自然顺序排序

如果想更精确更活的排序,可以采用Comparator接口

二十一.Iterable:可迭代的

可迭代的接口
与Iterator有关系 ,实现了Iterable接口的类,必定会返回一个Iterator
所有的Collection都实现了Iterable
Iterable 创建 Iterator

 

实现Iterable接口的类,都可以用ForEach来遍历
for(Object v : 实现了Iterable接口的类){

}

二十二.Collections

1 概述
Collections 是操作Collection的工具类,里面的方法都是static的,包括二分查找法,排序,反转,填充,打乱,生成不可变的集合。。。。

2 重点学习
binarySeach()-快速在List集合中查找指定的对象,前提是查找之前要对List先进行正排序,返回-1表示找不到指定的元素
sort() - 按自然排序
sort(Comparator) - 按比较器定制的规则来排序,可以用自定义比较器来实现排序,比如是倒叙排序。
reverse() - 将List集合的元素反转
fill() - 填充
shuffle() -打乱,打纸牌。

3.面试题:
Collection 和 Collections的区别。
Collections是个java.util下的类,它包含有各种有关集合操作的静态方法。
Collection是个java.util下的接口,它是各种集合结构的父接口。

public class TestCollections {
public static void main(String[] args) {
List list = new ArrayList();
list.add(2);
list.add(1);
list.add(5);
Collections.sort(list,new MyComparator());//按照比较器排序
System.out.println(list);
}
}
class MyComparator implements Comparator{
@Override
public int compare(Object o1, Object o2) {
int i1 = (Integer)o1;
int i2 = (Integer)o2;
return -(i1-i2);
}
}

 

 

二十三.Arrays

1 概述
用来操作数组的工具为在,包括填充,排序等等

2 API方法
asList(T[] a) - 将一个数组转的转换成List,与Collection的toArray()方法

 

binarySearch() - 二分查找
copyOf() - 复制指定数组的指定个数的元素,形成一个新的数组
copyOfRange() - 复制指定数组的指定范围的元素,形成一个新的数组
equals()- 比较2个数组是否"相同"
fill() - 用指定的元素来填充数组
sort() - 排序,如果不传比较器(Comparator),则按自然排序(Comparable),如果传了Comparator,就按比较器规则排序
toString() - 将数组转成字符的格式

二十四.枚举接口:Enumeration

public static void main(String[] args) {
    Vector v = new Vector();
    v.add("java");
    v.add("oracle");
    v.add("linux");
    v.add("html");
    //Iterator
    Enumeration<String> e = v.elements();
    while(e.hasMoreElements()){
      String s = e.nextElement();
      System.out.println(s);
    }
    String s = null;
    for(Enumeration<String> e2 = v.elements();e2.hasMoreElements();){
     s = e2.nextElement();
      System.out.println(s);
    }
 }
 

 

二十五.包装类

(1)概述

在java里,我们有八个基本数据类型,它们可以做各种运算,例如加减乘除。。。
但是这些基本数据类型没有更多的方法给开发者使用,所以Java对每个基本数据类型都提供一个包装类与之对应
byte - Byte
short - Short
int - Integer
long - Long
float - Float
double - Double
char - Character
boolean - Boolean

这也体现了java是一种完全面向对象的语言。
面试题:java提供了八大基本数据型的包装类,为什么还保留原来的基本数据类型?
1) 包装类型没有提供相应的(+,—,*,/等)运算方法
2) 包装类的对象比基本类型占用更多的内存
3)基本数据类型操作起来更加简单方便。

 

(2)封箱解箱

 

自动封箱解箱,是Jdk1.5开始提供的新特性

自动封箱:将基本类型自动包装成包装类,这个过程是由编译器自动完成
//想调用基本数据类型的更多功能,必须转换为相应的包装类型
Integer i = 6;//编译器:Integer i = new Integer(6);//自动封箱
System.out.println(i);


自动解箱:将包装类型自动转换成基本类型,这个过程是由编译器自动完成
//想更方便的操作,就解箱为基本数据类型,+-*/
Integer i2 = new Integer(7);
int i3 = i2;//编译器:int i3 = i2.intValue();//自动解箱
System.out.println(i3);
list.add(7);//自动封箱,相当于list.add(new Integer(7));
int i = list.get(0); //自动解箱,相当于int i = list.get(0).intValue(); 小心预防抛nullPoiterException

以下要小心,这样会抛nullPoiterException
Integer i = null;
int b = i;//相当于int b = null.intValude(); 所以抛nullPoiterException


 

(3)使用

/*
     String s = "123";
     int i1 = Integer.parseInt(s);
     Integer i2 = Integer.valueOf(s);
     */
     
     Scanner scan = new Scanner(System.in);
     while(true){
       String iStr = scan.nextLine();
       int i = Integer.parseInt(iStr);
       System.out.println("----->"+i);
       String line = scan.nextLine();
       System.out.println("String类型的:"+line);
     }

 

(4)常量池

Integer这个包装类内部维护了一个常量池,类似String了维护常量池。
这个常量池能够缓存-128 ~ 127 这个范围的包装类对象,可以通过IntegerCatch查看常量池源码。
当我们创建一个新的在-128~127之间的值时,实际上是直接到常量池里去取。
Integer i3 = 112; //new Integer(112),会被放入常量池
Integer i4 = 112; //直接从常量池中取出已有对象
System.out.println(i3==i4);//true 同一个对象

Integer i3 = 130; //不会放入常量池,常量池只装-128 ~ 127的对象
Integer i4 = 130;
System.out.println(i3==i4);//false 注意:超过127不会被存到常量池中,会重新new一个对象。
而下面这2个代码不会去常量池去取
Integer i5 = new Integer(112);
Integer i6= new Integer(112);
System.out.println(i5==i6);
作用:
是为了方便快捷地创建某些对象而出现的,当需要一个对象时,就可以从池中取一个出来(如果池中没有则创建一个),则在需要重复重复创建相等变量时节省了很多时间。
要比较2个Integer对象是否相等,要用equals()方法

以上是关于java集合与包装类的主要内容,如果未能解决你的问题,请参考以下文章

初识Java集合及包装类和泛型的基本使用

Java:为啥需要包装类?

java中Collection与Collections的区别

学习java正则与集合框架小总结

Arrays类,包装类,正则表达式,集合

JAVA之旅(十八)——基本数据类型的对象包装类,集合框架,数据结构,Collection,ArrayList,迭代器Iterator,List的使用