集合是一种容器,数组也是一种容器
在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里没有方法体
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中集合主要分为三类
List的特征是其元素以线性方式存储,集合中可以存放重复对象。
List接口主要实现类包括:
对于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没有继承于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接口主要实现了两个实现类:
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类型者,键值对,类似于数据库。
注意:
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允许重复。