List接口常用方法
1、List集合存储元素特点:有序可重复
有序:List集合中的元素有下标,从0开始,依次递增
可重复:存储的元素可以重复
2、List既然是Collection接口的子接口,那么肯定List接口有自己"特色"的方法;
以下只列出List接口特有的常用的方法
void add(int index,E element) 在列表的指定位置插入指定元素
E get(int index) 返回列表中指定位置的元素
int indexOf(Object o) 返回此列表中第一次出现的指定元素的索引;如果此列表不包含该元素,则返回-1
int LastIndexOf(Object o)返回此列表中最后一次出现的指定元素的索引
E remove(int index) 移除列表中指定位置的元素
E set(int index,E element) 用指定元素替换列表中指定位置的元素
public class ListTest01 {
public static void main(String[] args) {
//创建List类型的集合
// List myList = new LinkedList();
List myList = new ArrayList();
//添加元素
myList.add("A");//默认都是向集合末尾添加元素
myList.add("B");
myList.add("C");
myList.add("C");
myList.add("D");
myList.add(1,"KING");//在列表的指定位置插入指定元素
//迭代
Iterator it = myList.iterator();
while (it.hasNext()){
Object o = it.next();
System.out.println(o);
}
//根据下标获取元素
Object firstObj = myList.get(0);
System.out.println(firstObj);
//因为有下标,所以List集合有自己比较特殊的遍历方式
//List集合特有的方式,Set没有
for(int i = 0;i<myList.size();i++){
Object obj = myList.get(i);
System.out.println( obj);
}
//获得指定对象第一次出现的索引
System.out.println(myList.indexOf("C"));//3
//获取指定对象最后一次出现处的索引
System.out.println(myList.lastIndexOf("C"));//4
//删除指定下标位置的元素
//删除下标为0的元素
myList.remove(0);
System.out.println(myList.size());//5
System.out.println("======================");
//修改指定位置的元素
myList.set(2,"soft");
//遍历集合
for(int i = 0;i<myList.size();i++){
Object obj = myList.get(i);
System.out.println( obj);
}
}
}
/*
增:add、save、new
删:delete、drop、remove
改:update、set、modify
查:find、get、query、select
*/
ArrayList集合
ArrayList集合
1、默认初始化容量10。(底层先创建一个长度为0的数组,当添加第一个元素的时候,初始化容量10)
2、集合底层是一个Object[]数组
3、构造方法:
new ArrayList();
new ArrayList(20);
4、ArrayList集合的扩容:
原容量的1.5倍
ArrayList集合底层是数组,怎么优化?
尽可能少的扩容。因为数组扩容效率比较低,建议在使用ArrayList集合的时候
估计元素的个数,给定一个初始化容量。
5、数组优点:检索效率比较高
数组缺点:随机增删元素效率比较低。但是向数组末尾添加元素,效率很高,不受影响
6、在这么多集合中,ArrayList集合使用最多
因为往数组末尾添加元素,效率不受影响。另外,检索/查找某个元素的操作比较多
7、ArrayList集合是非线程安全的。
public class ArrayListTest01 {
public static void main(String[] args) {
//默认初始化容量是10
//数组的长度是10
List list1 = new ArrayList();
//集合的size()方法是获取当前集合中元素的个数。不是获取集合的容量
System.out.println(list1.size());//0
//指定初始化容量
//数组的长度是20
List list2 = new ArrayList(20);
System.out.println(list2.size());//0
//创建一个HashSet集合
Collection c = new HashSet();
c.add(100);
c.add(200);
c.add(900);
c.add(50);
//通过这个构造方法就可以将HashSet集合转换成List集合
List list3 = new ArrayList(c);
for (int i = 0 ;i<list3.size();i++){
System.out.println(list3.get(i));
}
}
}
LinkList
单链表
/*
单链表中的节点:
节点是单向链表中的基本单元。
每一个节点Node都有两个属性:
一个属性:是存储的数据
另一个属性:是下一个节点的内存地址
*/
public class Node {
//存储的数据
Object element;
//下一个节点的内存地址
Node next;
public Node() {
}
public Node(Object element, Node next) {
this.element = element;
this.next = next;
}
}
public class Link {
//头结点
Node header ;
int size = 0;
public int size(){
return size;
}
//向链表中添加元素
public void add(Object data){
//创建一个新的节点对象
//让之前单链表的末尾节点next指向新节点对象
if (header == null){
//说明还没有节点
//new一个新的节点对象作为头节点对象
//这个时候的头结点既是一个头结点,又是一个末尾节点
header= new Node(data,null);
}else{
//说明头结点已经存在了
//找出当前末尾节点,让当前末尾节点的next是新节点
Node currentLastNode = findLast(header);
currentLastNode.next = new Node(data,null);
}
size++;
}
/**
* 专门查找末尾节点的方法
* @param node
* @return
*/
private Node findLast(Node node){
if(node.next==null){
return node;
}
return findLast(node.next);
}
}
public class Test {
public static void main(String[] args) {
Link link = new Link();
link.add(100);
link.add(200);
System.out.println(link.size);
}
}
双链表
链表的优点:
由于链表上的元素在空间存储上内存地址不连续。
所以随机增删元素的时候不会有大量元素位移,因此随机增删效率较高。
在以后的开发中。如果遇到随机增删集合中元素的业务比较多时,建议
使用LinkedList。
链表的缺点:
不能通过数学表达式计算被查找元素的内存地址,每-次查找都是从头
节点开始遍历,直到找到为止。所以LinkedList集合检索/查找的效率
较低。
ArrayList :把检索发挥到极致。
LinkedList :把随机增删发挥到极致。
加元素都是往末尾添加,所以ArrayList用的比LinkedList多。|
public class LinkListTest01 {
public static void main(String[] args) {
// LinkedList集合底层也是有下标的。
//注意:ArrayList之所以检索效率比较高,不是单纯因为下标的原因。是因为底层数组发挥的作用。
// LinkedList集合照祥有下标,但是检索/查找某个元素的时候效率比较低,因为只能从头节点开始一个一个遍历。
List list = new LinkedList();
list.add("a");
list.add("b");
list.add("c");
for(int i =0;i<list.size();i++){
Object obj = list.get(i);
System.out.println(obj);
}
//LinkList集合有初始化容量吗?没有
//最初这个链表中没有任何元素。first和last引用都是null。
//不管是LinkedList还是ArrayList,以后写代码时不需要关心具体是哪个集合。
//因为要面向接口编程,调用的方法都是接口中的方法。
//List list2 = new ArrayList();//底层是数组
List list2 = new LinkedList();//底层是双向链表
//以下这些方法都是面向接口编程
list2.add("123");
list2.add("456");
list2.add("789");
for(int i =0;i<list2.size();i++){
Object obj = list2.get(i);
System.out.println(obj);
}
}
}
Vector:
1、底层也是一个数组
2、初始化容量:10
3、怎么扩容?
扩容之后是原容量的2倍
4、ArrayList集合扩容特点:
扩容之后是原容量的1.5倍
5、Vector中所有的方法都是线程同步的,都带有synchronized关键字。
是线程安全的。效率比较低,使用较少。
6、怎么将一个线程不安全的ArrayList集合转换成线程安全的?
使用集合工具类
java.util.Collections;
java.util.Collection是集合接口
java.util.Collections是集合工具类
public class VectorTest {
public static void main(String[] args) {
//创建一个Vector集合
List vector = new Vector();
//Vector vector = new Vector();
vector.add(1);
vector.add(2);
vector.add(3);
//遍历
for(int i =0;i<vector.size();i++){
Object obj = vector.get(i);
System.out.println(obj);
}
//遍历
Iterator it = vector.iterator();
while (it.hasNext()){
Object obj = it.next();
System.out.println(obj);
}
List myList = new ArrayList();//非线程安全的
//变成线程安全的
Collections.synchronizedList(myList);
myList.add("111");
myList.add("222");
myList.add("333");
}
}