一、什么是List？
在集合框架中,List是一个接口,继承自Collection接口
List就是一个线性表,是n个具有相同类型元素的有限序列,可以进行增删改查等操作
List是一个接口,不能直接用来实例化,要使用,需要去实例化List的实现类(ArrayList和LinkedList实现了List接口)
线性表:是n个具有相同特性的数据元素的有限序列(顺序表,链表,栈,队列...),在物理上通常以数组和链式结构的形式存储;(逻辑上是线性结构,物理上并不一定连续)
顺序表:用一段物理地址连续的存储单元依次存储数据元素的线性结构,一般采用数组存储
顺序表接口的实现
import java.util.ArrayList;
import java.util.Arrays;
public class MyArrayList {
//数组
private int[] elem;
private int usedSize;//代表当前顺序表当中的有效数据个数
private static final int DEFAULT_SIZE=10;
public MyArrayList(){
this.elem=new int[DEFAULT_SIZE];
}
//指定容量
public MyArrayList(int initCapacity){
this.elem=new int[initCapacity];
}
// 新增元素,默认在数组最后新增
public void add(int data) {
if(isFull()){
//如果数组满了要扩容
this.elem= Arrays.copyOf(this.elem,2*this.elem.length);
}
this.elem[this.usedSize]=data;
usedSize++;
}
//判断数组是否填满
public boolean isFull(){
if(this.usedSize==this.elem.length){
return true;
}else {
return false;
}
}
// 在 pos 位置新增元素
public void add(int pos, int data) {
if(pos<0||pos>this.usedSize){
System.out.println("位置不合法");
return;
}
if (isFull()){
this.elem= Arrays.copyOf(this.elem,2*this.elem.length);
}
for (int i =this.usedSize-1; i >=pos ; i--) {
this.elem[i+1]=this.elem[i];
}
this.elem[pos]=data;
this.usedSize++;
}
// 判定是否包含某个元素
public boolean contains(int toFind) {
for (int i = 0; i <this.usedSize ; i++) {
//引用类型比较时用equals或者compareTo
if(this.elem[i]==toFind){
return true;
}
}
return false;
}
// 查找某个元素对应的位置
public int indexOf(int toFind) {
for (int i = 0; i <this.usedSize ; i++) {
if(this.elem[i]==toFind){
return i;
}
}
return -1;
}
// 获取 pos 位置的元素
public int get(int pos) {
if(pos<0||pos>=this.usedSize){
System.out.println("位置不合法");
return -1;
}
return this.elem[pos];
}
// 给 pos 位置的元素设为 value
public void set(int pos, int value) {
if(pos<0||pos>=this.usedSize){
System.out.println("位置不合法");
return ;
}
this.elem[pos]=value;
}
//删除第一次出现的关键字key
public void remove(int toRemove) {
int index=indexOf(toRemove);
if(index==-1){
System.out.println("没有这个元素");
return;
}
for (int i = index; i <this.usedSize-1 ; i++) {
this.elem[i]=this.elem[i+1];
}
this.usedSize--;
}
// 获取顺序表长度
public int size() {
return this.usedSize;
}
// 清空顺序表
public void clear() {
this.usedSize=0;
//如果为引用类型,清空时应给每个元素设为null
// for (int i = 0; i <this.usedSize ; i++) {
// this.elem[i]=null;
// }
}
// 打印顺序表，注意：该方法并不是顺序表中的方法，为了方便看测试结果给出的
public void display() {
for (int i = 0; i <usedSize ; i++) {
System.out.print(this.elem[i]+" ");
}
System.out.println();
}
}
class Test{
public static void main(String[] args) {
MyArrayList myArrayList=new MyArrayList();
myArrayList.add(1);
myArrayList.add(2);
myArrayList.add(3);
myArrayList.add(4);
myArrayList.add(5);
myArrayList.display();
System.out.println("============");
//在2位置新增9
myArrayList.add(2,9);
myArrayList.display();
System.out.println("=========");
//return虽然返回值但是要打印!!!
//判断是否含9
System.out.println(myArrayList.contains(9));
//查找1对应的位置
System.out.println(myArrayList.indexOf(1));
//获取1位置的元素
System.out.println( myArrayList.get(1));
//给5位置元素设置为999
myArrayList.set(5,999);
myArrayList.display();
//删除99
myArrayList.remove(99);
//获取数组长度
System.out.println(myArrayList.size());
//清空数组
myArrayList.clear();
System.out.println(myArrayList.size());
}
}
List常用方法
List中提供了一些方法可以直接使用,不用构造(上述)
boolean add(E e) 尾插 e
void add(int index, E element) 将 e 插入到 index 位置
boolean addAll(Collection c) 尾插 c 中的元素
E remove(int index) 删除 index 位置元素
boolean remove(Object o) 删除遇到的第一个 o
E get(int index) 获取下标 index 位置元素
E set(int index, E element) 将下标 index 位置元素设置为 element
void clear() 清空
boolean contains(Object o) 判断 o 是否在线性表中
int indexOf(Object o) 返回第一个 o 所在下标
int lastIndexOf(Object o) 返回最后一个 o 的下标
List subList(int fromIndex, int toIndex) 截取部分 list
三、ArrayList的使用
ArrayList是以泛型方式实现的
1)ArrayList的构造
public static void main(String[] args) {
//实现的方法比较多 ArrayList
ArrayList<Integer>list=new ArrayList<>();
ArrayList<Integer>list2=new ArrayList<>(10);
//向上转型1
//用接口引用一个具体的实现类List实现的方法比较少
List<Integer>list3=new ArrayList<>();
List<Integer>list4=new LinkedList<>();
list4.add(7);
list4.add(8);
list4.add(9);
List<Integer>list5=new ArrayList<>(list4);
list2.add(1);
list5.add(10);
//也是遍历顺序表的一种方式
System.out.println(list5);
}
2)ArrayList常见操作
ArrayList底层是一段连续的空间，并且可以动态扩容，是一个动态类型的顺序表
class Test{
public static void main(String[] args) {
ArrayList<Integer>list=new ArrayList<>();
//方法的使用
list.add(1);
list.add(2);
list.add(3);
//list.add(0,100);
list.add(4);
list.add(5);
//返回1下标的值
//System.out.println(list.get(1));
System.out.println(list);
//截取一段list左闭右开
List<Integer>list2=list.subList(1,3);
System.out.println(list2);
System.out.println("=======");
//删除0位置的下标
// list.remove(0);
// System.out.println(list);
// System.out.println("=======");
// //删除元素3的值
// list.remove(new Integer(3));
// System.out.println(list);
//把截取出来的list2[1,3],0下标改成99
list2.set(0,99);
System.out.println(list);
System.out.println(list2);
}
3)遍历
public static void main(String[] args) {
ArrayList<Integer>list=new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
//for遍历
for (int i = 0; i <list.size() ; i++) {
System.out.print(list.get(i)+" ");
}
System.out.println();
//foreach循环
for (Integer x:list){
System.out.print(x+" ");
}
System.out.println();
//迭代器iterator
Iterator<Integer>it=list.listerator();
while (it.hasNext()){
System.out.print(it.next()+" ");
}
System.out.println();
ListIterator<Integer>listIterator=list.listIterator();
while (listIterator.hasNext()){
System.out.print(listIterator.next()+" ");
}
System.out.println();
//从后往前遍历
ListIterator<Integer>listIterator2=list.listIterator(list.size());
while (listIterator.hasPrevious()){
System.out.print(listIterator.previous()+" ");
}
System.out.println();
}
4)ArrayList优缺点
1. ArrayList底层使用连续的空间，任意位置插入或删除元素时，需要将该位置后序元素整体往前或者往后搬 移，故时间复杂度为O(N)
2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。
3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继 续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。
优:可以通过下标进行随机访问
缺:添加/删除元素效率低(要移动元素),扩容的时候存在浪费空间情况
顺序表适合静态的数据查找和更新,不适合用来插入和删除数据(随用随分配链表来做)
四、toArray()方法的使用
List 接口中的 toArray() 方法用于将列表的内容转换为数组形式返回。这个方法提供了两种主要的使用方式，一种是不带参数的 toArray() 方法，另一种是带参数的 toArray(T[] a) 方法。这两种方法允许你以不同的方式获取列表内容的数组表示。
1. 不带参数的 toArray() 方法
Object[] toArray()
功能：
- 返回一个包含列表中所有元素的数组。
- 数组的类型为
Object[]，即数组中的每个元素都是Object类型的对象。
示例：
import java.util.ArrayList;
import java.util.List;
public class ToArrayExample {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Cherry");
Object[] array = list.toArray();
for (Object item : array) {
System.out.println(item);
}
}
}
输出：
Apple
Banana
Cherry
注意，这种方法返回的是 Object[] 类型的数组，如果需要特定类型的数组，则需要进行类型转换或使用第二种方法。
2. 带参数的 toArray(T[] a) 方法
<T> T[] toArray(T[] a)
功能：
- 返回一个按照列表顺序包含所有元素的数组，并且该数组的运行时类型是指定数组类型的副本。
- 如果提供的数组足够大，就直接在该数组中填充数据；否则，会分配一个新的数组来容纳所有的元素。
- 如果提供的数组比列表长，那么在新数组的最后一个元素之后的位置会被设置为
null（这可以用来确定列表的确切长度）。
示例：
import java.util.ArrayList;
import java.util.List;
public class ToArrayWithParameterExample {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Cherry");
// 提供一个大小至少与列表相同的数组
String[] fruitsArray = list.toArray(new String[0]);
for (String fruit : fruitsArray) {
System.out.println(fruit);
}
}
}
输出：
Apple
Banana
Cherry
在这个例子中，我们传递了一个大小为 0 的数组作为参数，MyBatis 会自动创建一个合适大小的新数组并返回它。当然，如果你事先知道列表的大小，也可以提供一个相同大小的数组来避免额外的对象创建。
总结
- 使用无参的
toArray()方法可以快速地将列表转换成Object[]类型的数组。 - 使用带参数的
toArray(T[] a)方法可以获得指定类型的数组，这样就无需手动进行类型转换，更加方便和安全。当不确定数组大小时，通常可以传入一个零长度的数组，如new String[0]，让 MyBatis 自动处理数组的大小问题。
扫一扫
794
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
