文章目录
List接口
- List集合类中元素有序（即添加和取出顺序一致），且可重复
- List集合中的每个元素都有其对应的顺序索引，即支持索引；
- List容器中的元素都对应一个整数型的序号记其在容器中的位置，可以根据序号存取容器中的元素
- List常用接口有 ArrayList、LinkedList、Vector
//1.List集合类中元素有序（即添加和取出顺序一致），且可重复
List list = new ArrayList();
list.add("Jack");
list.add("Tom");
list.add("Marry");
list.add("Marry");
System.out.println(list);
//[Jack, Tom, Marry, Marry]取出输出顺序和存放顺序一致,且可重复
//2.List集合中的每个元素都有其对应的顺序索引，即支持索引
System.out.println(list.get(2));//Marry
//3.List容器中的元素都对应一个整数型的序号记其在容器中的位置，可以根据序号存取容器中的元素
> List 接口的常用方法
- void add (int index,Object ele) ：在index位置插入ele元素；
- boolean addAll (int index,Collection eles) ：从index位置开始将eles集合中的所有元素添加进来；
- Object get (int index) ：获取指定index位置的元素；
- int indexOf (Object obj) ：返回obj在集合中首次出现的位置；
- int lastIndexOf (Object obj) ：返回obj在集合中末次出现的位置；
- Object remove (int index) ：移除指定index位置的元素，并返回此元素；
- Object set (int index,Object ele) ：设置指定index的位置的元素为ele，相当于是替换；
- List subList (int fromIndex,int toIndex) ：返回从fromIndex到toIndex位置的子集合；
更多方法可以自行JDK API在线查询 或 下载中文版JavaAPI帮助文档【免费0积分下载】
//向上转型，用List来接收ArrayList
List list = new ArrayList();
//1. void add (int index,Object ele) ：在index位置插入ele元素；
list.add("开心的你");
list.add(0,"帅气的我");//在0位置插入
System.out.println(list);//[帅气的我, 开心的你]
//2. boolean addAll (int index,Collection eles) ：从index位置开始将eles集合中的所有元素添加进来；
List list1 = new ArrayList();
list1.add("Jack");list1.add("Tom");list1.add("Marry");
list.addAll(1,list1);
System.out.println(list);//[帅气的我, Jack, Tom, Marry, 开心的你]
//3. Object get (int index) ：获取指定index位置的元素；
System.out.println(list.get(0));//帅气的我
//4. int indexOf (Object obj) ：返回obj在集合中首次出现的位置；
System.out.println(list.indexOf("开心的你"));//4
//5. int lastIndexOf (Object obj) ：返回obj在集合中末次出现的位置；
list.add("Jack");
System.out.println(list.lastIndexOf("Jack"));//5
//6. Object remove (int index) ：移除指定index位置的元素，并返回此元素；
System.out.println(list.remove(5));//Jack
System.out.println(list);//[帅气的我, Jack, Tom, Marry, 开心的你]
//7. Object set (int index,Object ele) ：设置指定index的位置的元素为ele，相当于是替换；
list.set(1,"!!!");
System.out.println(list);//[帅气的我, !!!, Tom, Marry, 开心的你]
//8. List subList (int fromIndex,int toIndex) ：返回从fromIndex到toIndex位置的子集合；
//返回的子集合： [fromIndex,toIndex) 左闭右开
System.out.println(list.subList(2,4));//[Tom, Marry]
> List的三种遍历方式
import java.util.*;
public class ListFor {
public static void main(String[] args) {
//List的实现接口子类ArrayList LinkedList Vector
//List list = new ArrayList();
//List list = new LinkedList();
List list = new Vector();
list.add("熊大");
list.add("熊二");
list.add("光头强");
//迭代器iterator遍历
Iterator iterator = list.iterator();
while(iterator.hasNext()){
Object next = iterator.next();
System.out.println(next);
}
//增强for遍历
for (Object o:list) {
System.out.println(o);
}
//普通遍历
for (int i=0;i<list.size();i++){
System.out.println(list.get(i));
}
}
}
> List 排序练习
import java.util.ArrayList;
import java.util.List;
public class Demo {
public static void main(String[] args) {
//List list = new ArrayList();
//List list = new LinkedList();
List list = new Vector();
list.add(new Book("红楼梦", 36.4f, "曹雪芹"));
list.add(new Book("水浒传", 19.9f, "施耐庵"));
list.add(new Book("西游记", 28.8f, "吴承恩"));
//遍历
for(Object o:list){
System.out.println(o);
}
//冒泡排序
sort(list);
System.out.println("---- 排序后 ----");
for(Object o:list){
System.out.println(o);
}
}
//静态方法：冒泡排序
//要求价格从小到大
public static void sort(List list){
for (int i=0;i<list.size();i++){
for (int j=0;j<list.size()-1-i;j++){
//取出对象book
Book book1 = (Book) list.get(j);
Book book2 = (Book) list.get(j+1);
if(book1.getPrice()>book2.getPrice()){
//交换
list.set(j,book2);
list.set(j+1,book1);
}
}
}
}
}
class Book{
private String name;
private float price;
private String author;
@Override
public String toString() {
return "书名： "+name+" 价格： "+price+" 作者： "+author;
}
public Book(String name, float price, String author) {
this.name = name;
this.price = price;
this.author = author;
}
public void setName(String name) {
this.name = name;
}
public void setPrice(float price) {
this.price = price;
}
public void setAuthor(String author) {
this.author = author;
}
public String getName() {
return name;
}
public float getPrice() {
return price;
}
public String getAuthor() {
return author;
}
}
※ ArrayList 使用注意事项
- 允许存放任何元素，包括空元素null
ArrayList list = new ArrayList();
list.add(null);
list.add("OK")；
list.add(null);
System.out.println(list);
//[null,OK,null]
- ArrayList 是由数组来实现数据存储的；
- ArrayList基本等同于 Vector ，除了 ArrayList是线程不安全的，但执行效率高，在多线程的情况下不建议用ArrayList；
※ ArrayList 底层结构
- ArrayList中维护了一个Object类型的数组
transient Object[ ] elementData; //transient 短暂的 表示该属性不会被序列化 - 当创建ArrayList对象时，如果使用的是无参构造器，则初始elementData容量为0 ，第一次添加则扩容elementData为10，如需要再次扩容，则扩容elementData为1.5 倍；
- 如果使用的是指定大小的构造器，则初始扩容elementData容量为指定大小，如果需要再次扩容，则直接扩容为1.5倍；
※ Vector 底层结构
- Vector 底层也是一个对象数组，protected Object[ ] elementData；
- Vector 是线程同步的，即线程安全，Vector类的操作方法带有synchronized
- 在开发中，需要线程同步安全时，考虑使用Vector
※ LinkedList 底层结构 （双向链表和增删改查案例）
- LinkedList 实现了双向链表和双端队列的特点
- 可以添加任意元素（元素可以重复），包括null；
- 线程不安全，没有实现同步
- LinkedList底层维护了一个双向链表；
- LinkedList中维护了两个属性first和last分别指向 首节点 和 尾节点；
- 每个节点（Node对象），里面又维护了prev、next、item三个属性，其中通过prev指向前一个，通过next指向后一个节点，最终完成双向链表；
- 所以 LinkedList的元素的添加和删除不是通过数组完成的，相对来说效率较高；
双向链表的模拟：
public class TestLinkedList01 {
public static void main(String[] args) {
//模拟一个简单的双向链表
Node jack = new Node("Jack");
Node tom = new Node("Tom");
Node marry = new Node("Marry");
//连接三个节点，形成双向链表
//jack -> tom -> marry
jack.next = tom;
tom.next = marry;
//jack <- tom <- marry
marry.pre = tom;
tom.pre = jack;
Node first = jack;//让first引用指向jack，就是双向链表的首节点
Node last = marry;//让last引用指向marry，就是双向链表的尾节点
//演示 从头到尾 遍历
System.out.println("--------- 从头到尾的遍历 --------");
while(true){
if(first == null){
break;
}
//输出first信息
System.out.println(first);
first = first.next;//输出完以后，first指向下一个
/*
Node name = Jack
Node name = Tom
Node name = Marry
进程已结束,退出代码0
*/
}
//从尾到头的遍历
System.out.println("--------- 从尾到头遍历 --------");
while(true){
if(last == null){
break;
}
//输出last信息
System.out.println(last);
last = last.pre;//输出完以后，first指向下一个
/*
Node name = Marry
Node name = Tom
Node name = Jack
*/
}
//演示链表的添加对象/数据
//在tom和marry之间插入一个对象
//1.先创建一个Node节点,name为smith
Node smith = new Node("Smith");
//2.把smith加入双向链表
smith.next = marry;
smith.pre = tom;
marry.pre = smith;
tom.next = smith;
//3.让first再次指向jack
first = jack;
//演示 从头到尾 遍历
System.out.println("--------- 插入smith后 从头到尾的遍历 --------");
while(true){
if(first == null){
break;
}
//输出first信息
System.out.println(first);
first = first.next;//输出完以后，first指向下一个
}/*
Node name = Jack
Node name = Tom
Node name = Smith
Node name = Marry
*/
}
}
//定义一个Node类，Node对象表示双向链表的一个节点
class Node{
public Object item;//真正存放数据的地方
public Node next;//指向下一个节点
public Node pre;//指向前一个节点
public Node(Object name){
this.item = name;
}
public String toString(){
return "Node name = "+item;
}
}
LinkedList的增删改查案例：
import java.util.Iterator;
import java.util.LinkedList;
public class LinkListCRUD {
public static void main(String[] args) {
LinkedList linkedList = new LinkedList();
//增
linkedList.add(1);//size=0添加一个新节点，首尾指针都指向这个新节点
linkedList.add(2);//last指向新节点，first还是指向第一个节点，next指向新节点
linkedList.add(3);
System.out.println("增后： "+linkedList);
//删
linkedList.remove();//默认删除第一个
System.out.println("删后： "+linkedList);//就是去掉指针
//改
linkedList.set(1,999);
System.out.println("改后： "+linkedList);
//查
//get(1) 得到双向链表的第二个对象
Object o = linkedList.get(1);
System.out.println(o);//999
//因为LinkedList是实现了List接口，所以遍历方式：
Iterator iterator = linkedList.iterator();
while (iterator.hasNext()) { //快捷输入itit
Object next = iterator.next();
System.out.println(next);
}
//还有增强for 和普通for 遍历
}
}
(可以自行debug看一下调用方法的实现)
> ArrayList 和 LinkedList 比较
| 集合 | 底层结构 | 增删的效率 | 改查的效率 |
|---|---|---|---|
| ArrayList | 可变数组 | 较低，数组扩容 | 较高 |
| LinkedList | 双向链表 | 较高，通过链表追加 | 较低 |
如何选择 ArrayList 和 LinkedList :
- 如果改查的操作较多，选择 ArrayList；
- 如果增删的操作较多，选择 LinkedList；
- 一般程序中，80%-90%都是查询，因此大部分会使用ArrayList；
- 在项目中，灵活选择，可以一个模块用LinkedList，一个模块用ArrayList；
多线程的情况还是考虑 Vector ，因为它是线程安全的
扫一扫
578
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
