数组存储的缺点
1、数组一旦初始化后,其长度和类型就确定了;
2、数组中提供的方法有限、对于增删改等操作不方便,效率也不高
3、能够解决有序、可重复,但对于无序和不可重复的需求时,不能够满足
基本概念
当需要在java程序中记录单个数据内容时,则声明一个变量即可;
当需要在java程序中记录多个类型相同的数据内容时,则声明一个一维数组即可;
当需要在java程序中记录多个类型不同的数据内容时,则创建一个对象即可;
当需要在Java程序中记录多个类型相同的对象数据时,则创建一个对象数组即可;
当需要在Java程序中记录多个类型不同的对象数据时,则准备一个集合即可;
集合框架
Java中集合框架的顶层框架是:java.util.Collection集合和java.util.Map集合。
其中Collection集合中存取元素的基本单位是:单个元素。其中Map集合中存取元素的基本单位是:单对元素。
Collection集合(重点)
常用方法
boolean add(E e):向集合中添加对象
boolean contains(Object o):判断是否包含指定对象
boolean remove(Object o):从集合中删除对象
void clear();//清空集合
int size();//返回包含对象的个数
boolean isEmpty();//判断是否为空
Object[] toArray();//将集合转换成数组
List asList(Object[] o);//将数组转换成集合
Iterator<E> iterator():遍历集合中的元素
Iterator对象称为迭代器,主要用于遍历Collection集合中的元素
boolean hasNext():如果仍有元素可以迭代,则返回true
E next():退回迭代的下一个元素
注意:集合对象每次调用iterator()方法都得到一个全新的迭代器对象,默认游标都在集合的第一个元素之前。
使用foreach循环遍历集合元素:JDK1.5提供,可以选代访问Collection和数组
遍历时不需要获取Collection或数组的长度,也不需要使用索引访问
本质上,底层也是调用iterator
格式:
for(要遍历的元素类型 遍历后自定义元素名称:要遍历的结构名称){
System.out,println(遍历后自定义元案名称);
}
public void collectionTest(){
//接口类型的引用指向实现的对象,形成多态
Collection collection = new ArrayList();
// []
System.out.println(collection);
// 向集合中添加元素,该方法的形参要求是Object类型
// [one]
boolean b = collection.add("one");
System.out.println(collection);
// true
System.out.println("b = " + b);
// [one, 2]
collection.add(2);
System.out.println(collection);
collection.add('a');
collection.add(3.14);
collection.add("张三");
// [one, 2, a, 3.14, 张三]
System.out.println(collection);
System.out.println("----------------------");
//判断是否包含对象
b = collection.contains("two");
System.out.println("b = " + b);
b = collection.contains("one");
System.out.println("b = " + b);
//判断是否为空
b = collection.isEmpty();
System.out.println("b = " + b);
System.out.println("======================");
System.out.println("集合中的元素有:" + collection);
b = collection.remove("one");
System.out.println("b = " + b);
System.out.println("集合中的元素有:" + collection);
System.out.println("======================");
//集合转换为数组
Object[] objects = collection.toArray();
//地址值
System.out.println(objects);
//遍历数组中的元素
for (int i = 0; i < objects.length; i++) {
System.out.println(objects[i]);
}
System.out.println("======================");
//将数组转换为集合
List objects1 = Arrays.asList(objects);
System.out.println(objects1);
System.out.println("======================");
//迭代器,遍历集合中的元素 方式二
Iterator it = objects1.iterator();
// b = it.hasNext();
// System.out.println("b = " + b);
// Object obj = it.next();
// System.out.println("元素:" + obj);
while (it.hasNext()){
Object obj = it.next();
System.out.println(obj);
// String str = (String) it.next();
// System.out.println(str);
}
System.out.println("=================================");
//遍历集合中的元素,第三种方式
for (Object o: objects1) {
System.out.println(o);
}
}
List集合(重点)
基本概念
java.util.List集合是Collection集合的子集合,该集合中允许有重复的元素并且有先后放入次序。该集合的主要实现类有:ArrayList类、LinkedList类、Stack类、Vector类。
其中ArrayList类的底层是采用动态数组进行数据管理的,支持下标访问,增删元素不方便。
其中LinkedList类的底层是采用双向链表进行数据管理的,访问不方便,增删元素方便。
其中Stack类的底层是采用动态数组进行数据管理的,该类主要用于描述一种具有后进先出特征的数据结构,叫做栈(last in first out LlFO)。
其中Vector类的底层是采用动态数组进行数据管理的,该类与ArrayList类相比属于线程安全的类,效率比较低。
常用的方法
void add(int index, E element):向集合中指定位置添加元素
boolean addAll(int index, Collection<? extends> c):向集合中添加所有元素
E get(int indox):从集合中获取指定位置元素
E set(int index, E element):修改指定位置的元素
E remove(int index):删除指定位置的元素
List<E> subList(int fromIndex, int to Index);//获取子List,前闭后开
注意:subList获取的List与原List占有相同的存储空间,对子List的操作会影响到原List
public void listTest(){
//查询java.util.Stack类以及相关方法,实现将11、22、33、44、55依次入栈并打印,
//查者栈顶元素并打印,然后依次出栈并打印。
List list = new ArrayList();
int size = list.size();
//0
System.out.println(size);
//[]
System.out.println(list);
//向集合中添加元素
list.add(0,"one");
list.add(1,2);
list.add(2,'3');
list.add(3,3.14);
System.out.println(list);
List list1 = new ArrayList();
list1.add("two");
list1.add(10);
list.addAll(list1);
System.out.println(list);
System.out.println("------------------");
//根据下标查看原集合中指定位置的元素
Object o = list.get(3);
System.out.println(o);
//根据下标修改集合中指定位置的元素
o = list.set(0, 1);
System.out.println("下标为0的位置修改前为:" + o);
System.out.println(list);
//根据下标删除集合指定位置的元素
o = list.remove(0);
System.out.println("删除的元素为:" + o);
System.out.println("==========================");
List list2 = list.subList(0, 3);
//前闭后开
System.out.println("list集合:" + list);
System.out.println("子集合中的元素:" + list2);
//list与list2指向的地址一样,所以删除list2下标为0的元素同时也删除了list的该元素
list2.remove(0);
System.out.println("list集合:" + list);
System.out.println("子集合中的元素:" + list2);
}
Queue集合(重点)
基本概念
java.util.Queue集合是Collection集合的子集合,与List集合属于平级关系。该集合的主要用于描述具有先进先出特征的数据结构,叫做队列(first in first out FlFO)该集合的主要实现类是LinkedList类,因为该类在增删方面比较有优势.
常用的方法
boolean add(E e):将指定的元素插入此队列(如果立即可行且不会违反容量限制),在成功时返回 true,如果当前没有可用的空间,则抛出 IllegalStateException。
E element():获取,但是不移除此队列的头。
boolean offer(E e):将指定的元索插入此队列(如果立即可行且不会违反容量限制),当使用有容量限制的队列时,此方法通常要优于add(E),后者可能无法插入元素,而只是抛出一个异常。
E peek():获取但不移除此队列的头;如果此队列为空,则返回null。
E poll():获取并移除此队列的头,如果此队列为空,则返回 null。
E remove():获取并移除此队列的头。
public void queueTest(){
//准备一个Queue集合
Queue<Integer> queue = new LinkedList<>();
// 将数据11、22、33、44、55依次入队并打印
for (int i = 1; i < 6; i++) {
queue.offer(i * 11);
System.out.println(queue);
}
// 查看队首元素并打印
Integer it = queue.peek();
System.out.println("队首元素:" + it);
// 将队列中所有数据依次出队并打印
//poll
for (int i = 1; i < queue.size() + i; i++) {
Integer it1 = queue.poll();
System.out.println(it1);
}
}
泛型机制
基本概念
通常情况下集合中可以存放不同类型的对象,是因为将所有对象都看做Object类型放入的,因此从集合中取出元素时也是Object类型,为了表达该元素真实的数据类型,则需要强制类型转换,而强制类型转换可能会引发类型转换异常。为了避免上述错误的发生,从jdk1.5开始增加泛型机制,也就<数据类型>的方式来明确要求该集合中可以存放的元素类型,若放入其它类型的元素则编译报错,如:
List<String> lt1 = new LinkedList<String>();
泛型机制的本质
泛型机制的本质就是参数化类型,也就是让数据类型作为参数传递,其中E相当于形式参数负责占位,而使用集合时<>中的数据类型相当于实际参数,实际参数主要用于给形式参数初始化,一旦初始化成功,以后所有的E全部被实参取代,如:
public void collectionTest02(){
Collection<String> collection = new ArrayList<>();
collection.add("AA");
collection.add("BB");
collection.add("CC");
collection.add("DD");
System.out.println(collection);
}