java基础------集合ArrayList ,LinkedList
目录
- 前言
- 数组与集合区别
- 集合描述
- 集合格式
- 方法
- ArrayList实例
- 1.add(E e)
- 2.add(int index, E element)
- 3.addAll(Collection c)
- 4.clear() 与 isEmpty()
- 5.contains(Object o)
- 6.indexOf(Object o)
- 7.iterator()
- 8.remove(int index)
- 9.removeAll(Collection c)
- 10.remove(int index) 移位
- 11.set(int index, E element)
- 12. subList(int fromIndex, int toIndex)
- 13.toArray()
- 14.sort(Comparator c)
- LinkedList实例
- 1.常用方法
- 2.remove()之移位方案
- 3.linkedlist三种遍历
- 总结
前言
Java集合类是我们在工作中运用最多的、最频繁的类。相比于数组(Array)来说，集合类的长度可变，更加适合于现代开发需求；
数组与集合区别
集合描述
Java集合就像一个容器，可以存储任何类型的数据，也可以结合泛型来存储具体的类型对象。在程序运行时，Java集合可以动态的进行扩展，随着元素的增加而扩大。在Java中，集合类通常存在于java.util包中。
Java集合主要由2大体系构成，分别是Collection体系和Map体系，其中Collection和Map分别是2大体系中的顶层接口。
Collection主要有三个子接口，分别为List(列表)、Set(集)、Queue(队列)。其中，List、Queue中的元素有序可重复，而Set中的元素无序不可重复；
List中主要有ArrayList、LinkedList两个实现类；Set中则是有HashSet实现类；而Queue是在JDK1.5后才出现的新集合，主要以数组和链表两种形式存在。
Map同属于java.util包中，是集合的一部分，但与Collection是相互独立的，没有任何关系。Map中都是以key-value的形式存在，其中key必须唯一，主要有HashMap、HashTable、TreeMap三个实现类。
集合格式
创建对象：与其他普通的引用数据类型创建方式完全相同，但是要指定容器中存储的数据类型：
ArrayList<要存储元素的数据类型> 变量名 = new ArrayList<要存储元素的数据类型>();
注意：
集合中存储的元素，只能为<>括号中指定的数据类型元素；
“<要存储元素的数据类型>”中的数据类型必须是引用数据类型，不能是基本数据类型；
方法
size() 长度
get()获取
add()添加
addALL() 将一个集合添加到另一个集合
remove()删除remove(new integer(1))
removeAll() 以集合的形式删除元数——
remove(index)
clear() 清空集合中的元素
isEmpty()集合中元素是否为空
iterator 迭代器
toArray 将集合中元素转换成数组
add(index,element)
add(0,10)0是索引10是新填值
indexof 返回索引值
contains(e)判断集合中是否有莫个元素
set(index,element)
修改集合中元素
sublist 获取集合中摸一范围的元素，以集合的形式返回，不包含结束索引
ArrayList实例
1.add(E e)
package 集合.ArrayList;
import java.util.ArrayList;
import java.util.List;
public class AarryList_clear_isEmpty {
public static void main(String[] args) {
//声明集合
List<Integer>list=new ArrayList<>();
//添加元素
list.add(1);
list.add(2);
list.add(3);
//列表中删除所有元素。
//list.clear();
//判断集合是否为空
boolean f=list.isEmpty();//
System.out.println(f);//false 如果将list.clear();注释去掉结果就为true
}
}
2.add(int index, E element)
package 集合.ArrayList;
import java.util.ArrayList;
import java.util.List;
public class ArrayLiat_add {
public static void main(String[] args) {
//声明集合
List<Integer> list =new ArrayList<>();
//向集合中添加元素
list.add(1);
list.add(2);
list.add(3);
//add列表中的指定位置插入指定的元素
list.add(0,10);
int num=list.get(0);
System.out.println("索引为0的元素："+num);//索引为0的元素：10
for (Integer integer : list) {
System.out.println(integer);//10 1 2 3
}
}
}
3.addAll(Collection c)
package 集合.ArrayList;
import java.util.ArrayList;
import java.util.List;
public class Arraylist_addAll {
public static void main(String[] args) {
/*
* 将一个集合添加到另一个集合
* */
//声明集合
List<Integer> list =new ArrayList<>();
//向集合中添加元素
list.add(1);
list.add(2);
list.add(3);
//声明集合
List<Integer>list1 =new ArrayList<>();
//将集合list添加到list1中
list1.addAll(list);
//长度
int nums=list1.size();
System.out.println("长度 :"+nums);//长度 :3
System.out.println(list1);//[1, 2, 3]
}
}
4.clear() 与 isEmpty()
package 集合.ArrayList;
import java.util.ArrayList;
import java.util.List;
public class AarryList_clear_isEmpty {
public static void main(String[] args) {
//声明集合
List<Integer>list=new ArrayList<>();
//添加元素
list.add(1);
list.add(2);
list.add(3);
//列表中删除所有元素。
//list.clear();
//判断集合是否为空
boolean f=list.isEmpty();//
System.out.println(f);//false 如果将list.clear();注释去掉结果就为true
}
}
5.contains(Object o)
package 集合.ArrayList;
import java.util.ArrayList;
import java.util.List;
public class ArrayList_contains {
public static void main(String[] args) {
//声明集合
List<Integer> list =new ArrayList<>();
//向集合中添加元素
list.add(1);
list.add(2);
list.add(3);
//contains(e)判断集合中是否有某个元素
boolean b=list.contains(new Integer(1));
System.out.println(b);//true
boolean b1=list.contains(1);
System.out.println(b1);//true
}
}
6.indexOf(Object o)
package 集合.ArrayList;
import java.util.ArrayList;
import java.util.List;
public class ArrayList_indexof {
public static void main(String[] args) {
//声明集合
List<Integer> list =new ArrayList<>();
//向集合中添加元素
list.add(1);
list.add(2);
list.add(3);
list.add(3);
list.add(3);
//返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
int num=list.indexOf(new Integer(1));
System.out.println(num);//0
/*
* indexof 寻找只是第一个3所以索引就都是2
* */
int num1=list.indexOf(3);
System.out.println(num1);//2
int num2=list.indexOf(3);
System.out.println(num2);//2
int num3=list.indexOf(6);
System.out.println(num3);//-1 说明该元素不存在集合中
}
}
7.iterator()
package 集合.ArrayList;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class arrayList_iterator {
public static void main(String[] args) {
//声明集合
List<Integer> list =new ArrayList<>();
//向集合中添加元素
list.add(1);
list.add(2);
list.add(3);
list.add(3);
list.add(3);
//
Iterator<Integer> integers =list.iterator();
/*
* integers.hasNext()//用来检测迭代器中是否有元素返回true flase
* for 循环是明确次数条件下
* 而当前没有明确次数
* 所有用while 只要条件成立就执行
* */
while (integers.hasNext()){
int num=integers.next();//获取迭代器中的元素
if (num==3){
integers.remove();//删除所有元素
}
}
//加强for循环
for (Integer integer : list) {
System.out.println(integer);
}
}
}
8.remove(int index)
package 集合.ArrayList;
import java.util.ArrayList;
import java.util.List;
public class ArrayList_remove {
public static void main(String[] args) {
//声明集合
List<Integer> list =new ArrayList<>();
//向集合中添加元素
list.add(1);
list.add(2);
list.add(3);
list.remove(1);
list.remove(new Integer(2));//指定需要删除元素，可它存在一个移位问题无法解决重复元素的删除
//返回此列表中的元素数。
int num=list.size();
//输出集合中元素个数
System.out.println("元素个数"+num);//元素个数2
System.out.println(list);//[1, 3]
}
}
9.removeAll(Collection c)
package 集合.ArrayList;
import java.util.ArrayList;
import java.util.List;
public class Arraylist_removeAll {
public static void main(String[] args) {
//声明集合
List<Integer> list =new ArrayList<>();
//向集合中添加元素
list.add(1);
list.add(2);
list.add(3);
list.add(4);
//声明集合
List<Integer>list1 =new ArrayList<>();
list1.add(1);
list1.add(2);
//从此列表中删除指定集合中包含的所有元素
list1.removeAll(list1);
for (Integer integer : list) {
System.out.println(integer);//1 2 3 4
}
//长度
int nums=list.size();
System.out.println("长度 :"+nums);//长度 :4
System.out.println(list);//[1, 2, 3, 4]
}
}
10.remove(int index) 移位
package 集合.ArrayList;
import java.util.ArrayList;
import java.util.List;
public class Arraylist_remove移位 {
public static void main(String[] args) {
List<Integer>list=new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(2);
list.add(3);
//遍历
for(int i = list.size()-1;i >=0;i--){
if (list.get(i)==2){
list.remove(i);//移除2
}
}
//遍历集合
for (Integer integer : list) {
System.out.println(integer);
}
}
}
11.set(int index, E element)
package 集合.ArrayList;
import java.util.ArrayList;
import java.util.List;
public class ArrayList_set {
public static void main(String[] args) {
//声明集合
List<Integer> list =new ArrayList<>();
//向集合中添加元素
list.add(1);
list.add(2);
list.add(3);
list.set(0,19);//用指定的元素替换此列表中指定位置的元素
int num=list.get(0);
System.out.println(num);//19
for (Integer integer : list) {
System.out.println(integer);//19 2 3
}
}
}
12. subList(int fromIndex, int toIndex)
package 集合.ArrayList;
import java.util.ArrayList;
import java.util.List;
public class ArrayList_subList {
public static void main(String[] args) {
//声明集合
List<Integer> list =new ArrayList<>();
//向集合中添加元素
list.add(1);
list.add(2);
list.add(3);
//获取集合中摸一范围的元素，以集合的形式返回，不包含结束索引
List<Integer>num=list.subList(0,2);
for (Integer integer : num) {
System.out.println(integer);//1 2
}
}
}
13.toArray()
package 集合.ArrayList;
import java.util.ArrayList;
import java.util.List;
public class ArrayList_toArray {
public static void main(String[] args) {
//声明集合
List<Integer> list =new ArrayList<>();
//向集合中添加元素
list.add(1);
list.add(2);
list.add(3);
Object[] num =list.toArray(); //将集合中元素转换成数组
//试试length,
System.out.println("数组长："+num.length);//数组长：3
//遍历数组
for (Object o : num) {
System.out.print(o);//123
}
}
}
14.sort(Comparator c)
package 集合.ArrayList;
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
//声明数组
int[]nums={1,4,3,5,67,7,8};
//输出
System.out.println(Arrays.toString(nums));//toString()是一个静态方法
Arrays.sort(nums);
System.out.println(Arrays.toString(nums));
}
}
LinkedList实例
1.常用方法
package 集合.LinkedList;
import java.util.LinkedList;
import java.util.List;
/**
* @author fengxun
* @version 1.0
* @date 2020/4/10 15:35
*/
public class linkedLink {
public static void main(String[] args) {
//声明集合
List<Integer>list=new LinkedList<Integer>();
//添加
list.add(1);
list.add(2);
list.add(3);
//获取集合中有几个元素
int num=list.size();
System.out.println("获取集合中有几个元素"+num);//3
//
int num1=list.get(1);
System.out.println(num1);//索引为1的值为2
}
}
package 集合.LinkedList;
import java.util.LinkedList;
import java.util.List;
public class Linkedlist {
public static void main(String[] args) {
//声明集合
List<Integer> list=new LinkedList<Integer>();
//添加
list.add(1);
list.add(2);
list.add(3);
//清空元素
//list.clear();
// 将集合种元素转换数组
//Object[] obj =list.toArray();
/*for (Object o : obj) {
System.out.println(o);//123
}*/
//获取元素索引
int num=list.indexOf(new Integer(1));
System.out.println(num);//0
//判断集合中是否包含元素（返回bollean）
boolean contains=list.contains(1);
System.out.println(contains);//true
//修改指定索引值
list.set(0,3);
for (Integer integer : list) {
System.out.println(integer);//3 2 3
}
}
}
2.remove()之移位方案
package 集合.LinkedList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
public class LinkedList_remove {
public static void main(String[] args) {
//声明集合
List<Integer> list=new LinkedList<Integer>();
//添加
list.add(1);
list.add(2);
list.add(2);
list.add(3);
//remove删除元素（弊端：当有重复元素时会漏删）
/* list.remove(new Integer(2));
for (Integer integer : list) {
System.out.println(integer);//输出123漏删一个二
}*/
//从后往前删
/* for(int i=list.size()-1;i>=0;i--){
int num=list.get(i);
if (num==2) {
list.remove(i);
}
}
for (Integer integer : list) {
System.out.println(integer);//13
}*/
//迭代器
Iterator<Integer>iterator =list.iterator();
while (iterator.hasNext()) {
int num=iterator.next();
if (num==2) {
iterator.remove();
}
}
for (Integer integer : list) {
System.out.println(integer);
}
}
}
3.linkedlist三种遍历
package 集合.LinkedList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
public class LinkedList_三种遍历 {
public static void main(String[] args) {
//声明集合
List<Integer> list=new LinkedList<Integer>();
//添加
list.add(1);
list.add(2);
list.add(3);
//第一种用for get
for (int i=0;i<list.size();i++){
int num=list.get(i);
System.out.println(num);//123
}
// 第二种 增强for
for (Integer integer : list) {
System.out.println(integer);//123
}
//第三种 迭代器(推荐)
Iterator<Integer> iterable=list.iterator();
while (iterable.hasNext()){
int num=iterable.next();
System.out.println(num);//123
}
}
}
总结
Collection：单列集合的根接口
（1）List：元素有序 可重复
（2）ArrayList：底层数据结构是数组，查询快，增删慢，线程不安全，效率高，可以存储重复元素
（3）LinkedList底层数据结构是链表，查询慢，增删快，线程不安全，效率高，可以存储重复元素
