25.集合框架-List接口及其子类(1)

guizhaiteng

已于 2022-08-18 17:35:33 修改

阅读量69

点赞数

分类专栏： java基础学习笔记文章标签： java java基础 java入门 java面试 java自学

于 2022-07-23 11:26:33 首次发布

本文链接：https://blog.csdn.net/guizhaiteng/article/details/125945089

版权

java基础学习笔记专栏收录该内容

39 篇文章 2 订阅

订阅专栏

集合框架

集合框架---java做好的用来管理乱七八糟的一堆数据的java类库
java中的集合框架总体被分为2个大部分
第一个大部分是用来处理单列数据的集合,最大的接口是Collection接口
例如: 100 "hello"
Collection接口之下有两个子接口:List接口/Set接口
List接口是用来处理有序的单列数据，可以有重复的元素。
Set接口是用来处理无序的单列数据，没有重复的元素,重复的元素算一个。
第二个大部分是用来处理键值对数据的集合,最大的接口是Map接口
例如: name[键]=zhangsan[值] 书的目录

关于List接口下的常用类-----ArrayList类

1.动态数组的存储结构
2.添加/删除数据慢，查询数据快
3.没有提供对第一个和最后一个元素的操作方法
4.有10个单位的初始容量
5.扩容机制是原来的1.5倍

ArrayList类构造方法:
ArrayList() 构造一个初始容量为10的空列表。
ArrayList(Collection c) 通过实现Collection 接口的子类/子接口对象创建一个列表
ArrayList(int initialCapacity) 构造具有指定初始容量的空列表。

package com.wangxing.testarraylist1;
import java.util.ArrayList;
import java.util.List;
public class TestArrayListClass {
	public static void main(String[] args) {
		//3.动态数组结构，查询速度快，添加删除速度慢
		//构造方法
		//ArrayList() 构造一个初始容量为10的空列表。
		ArrayList  array1=new ArrayList();
		List list1=new ArrayList();
		//ArrayList(int initialCapacity) 构造具有指定初始容量的空列表。
		ArrayList  array2=new ArrayList(20);
		List list2=new ArrayList(20);
		//ArrayList(Collection c) 通过实现Collection 接口的子类/子接口对象转换成一个ArrayList列表
		ArrayList  testlist=new ArrayList();
		ArrayList  mylist=new ArrayList(testlist);
		List list3=new ArrayList(testlist);
	}

}

ArrayList类常用实例方法:
boolean   add(Object o) 将指定的元素追加到此列表的末尾。
boolean   contains(Object o) 如果此列表包含指定的元素，则返回 true 。
Object    get(int index) 返回此列表中指定位置的元素。
int   indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
int   lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
Object    remove(int index) 删除该列表中指定位置的元素。
boolean   remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）。
Object    set(int index, Object  element) 用指定的元素替换此列表中指定位置的元素。
int   size() 返回此列表中的元素数。
boolean   isEmpty() 如果此列表不包含元素，则返回 true 。
void   clear() 从列表中删除所有元素。
Iterator<E>   iterator() 以正确的顺序返回该列表中的元素的迭代器。

package com.wangxing.testarraylist1;
import java.util.ArrayList;
import java.util.Iterator;
public class TestArrayListClass1 {
	public static void main(String[] args) {
		ArrayList  testlist=new ArrayList();	
		//测试ArrayList类的常用实例方法
		//boolean	add(Object o) 将指定的元素追加到此列表的末尾。 
		testlist.add("hello");
		testlist.add(true);
		testlist.add(12.5);
		testlist.add("hello");
		testlist.add(1234);
		testlist.add("hello");
		//int	size() 返回此列表中的元素数。 
		System.out.println("szie==="+testlist.size());
		//boolean	contains(Object o) 如果此列表包含指定的元素，则返回 true 。 
		System.out.println("contains==="+testlist.contains("nihao"));
		//Object 	get(int index) 返回此列表中指定位置的元素。
		System.out.println("get==="+testlist.get(2));
		//int	indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
		System.out.println("indexOf==="+testlist.indexOf("nihao"));
		//int	lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。 
		System.out.println("lastIndexOf==="+testlist.lastIndexOf("hello"));
		//Object 	remove(int index) 删除该列表中指定位置的元素。 
		//testlist.remove(1);
		//System.out.println("szie==="+testlist.size());
		//boolean	remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）。 
		//testlist.remove("hello");
		//System.out.println("szie==="+testlist.size());
		//System.out.println("get==="+testlist.get(2));
		//Object set(int index, Object  element) 用指定的元素替换此列表中指定位置的元素。 
		System.out.println("get==="+testlist.get(3));
		testlist.set(3,"nihao");
		System.out.println("get==="+testlist.get(3));
		//boolean	isEmpty() 如果此列表不包含元素，则返回 true 。
		System.out.println("isEmpty==="+testlist.isEmpty());
		//void	clear() 从列表中删除所有元素。 
		//testlist.clear();
		//System.out.println("isEmpty==="+testlist.isEmpty());
	}
}

遍历集合ArrayList

package com.wangxing.testarraylist1;
import java.util.ArrayList;
import java.util.Iterator;
public class TestArrayListClass2{
	public static void main(String[] args) {
		ArrayList  testlist=new ArrayList();	
		//测试ArrayList类的常用实例方法
		//boolean	add(Object o) 将指定的元素追加到此列表的末尾。 
		testlist.add("hello");
		testlist.add(true);
		testlist.add(12.5);
		testlist.add("hello");
		testlist.add(1234);
		testlist.add("hello");
		//遍历集合ArrayList
		//从ArrayList集合中逐个取出元素
		//1.普通的for循环
		for(int i=0;i<testlist.size();i++){
			System.out.println("普通for循环---"+testlist.get(i));
		}
		System.out.println("------------------------");
		//2.增强的for循环
		for(Object obj:testlist){
			System.out.println("增强的for循环---"+obj);
		}
		System.out.println("------------------------");
		//3.Iterator<E>	iterator() 以正确的顺序返回该列表中的元素的迭代器。 
		Iterator iterator= testlist.iterator();
		//iterator.hasNext()方法判断迭代器中是否存在元素，如果有元素就返回true,否则为false
		while(iterator.hasNext()){
			//iterator.next()从迭代器中取出当前元素
			Object obj=iterator.next();
			System.out.println("Iterator迭代器---"+obj);
		}
	}
}

关于List接口下的常用类-----LinkedList类

1.双向链表的存储结构
2.添加/删除快，查询数据慢
3.提供对第一个和最后一个元素的操作方法
4.没有初始容量
5.没有扩容机制

LinkedList类构造方法
LinkedList() 构造一个空列表。
LinkedList(Collection c)通过一个实现Collection接口的子类/子接口对象创建一个列表。

package com.wangxing.testlinkedlist2;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
public class TestLinkedListClass1 {
	public static void main(String[] args) {
		//LikedList构造方法
		//LinkedList() 构造一个空列表。 
		LinkedList  linked1=new LinkedList();
		List  list1=new LinkedList();
		//LinkedList(Collection c)通过一个实现Collection接口的子类/子接口对象转换成一个LinkedList
		ArrayList  testlist=new ArrayList();
		LinkedList  linked2=new LinkedList(testlist);
		List  list2=new LinkedList(testlist);
	}
}

LinkedList类实例方法:
boolean   add(Object o) 将指定的元素追加到此列表的末尾。
boolean   contains(Object o) 如果此列表包含指定的元素，则返回 true 。
Object    get(int index) 返回此列表中指定位置的元素。
int   indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
int   lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
Object    remove(int index) 删除该列表中指定位置的元素。
boolean   remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）。
Object    set(int index, Object  element) 用指定的元素替换此列表中指定位置的元素。
int   size() 返回此列表中的元素数。
boolean   isEmpty() 如果此列表不包含元素，则返回 true 。
void   clear() 从列表中删除所有元素。
Iterator<E>   iterator() 以正确的顺序返回该列表中的元素的迭代器。
多出一组对第一个元素和最后一个元素的操作方法
void   addFirst(Object e) 在该列表开头插入指定的元素。
void   addLast(Object  e) 将指定的元素追加到此列表的末尾。
Object    getFirst() 返回此列表中的第一个元素。
Object    getLast() 返回此列表中的最后一个元素。
Object    removeFirst() 从此列表中删除并返回第一个元素。
Object    removeLast() 从此列表中删除并返回最后一个元素。

为什么LinkedList会比ArrayList多出一组对第一个元素和最后一个元素的操作方法？
因为ArrayList是动态数组结构，他在查找第一个元素和最后一个元素的时很麻烦，而LinkedList采用的是双向链表结构，这种结构在查找第一个元素和最后一个元素的时候是最快的。就像一列火车我们眼前驶过，我们可能不知道这列火车由几节车厢组成，但是我们一定会在第一时间看清第一节与最后一节车厢位置。

package com.wangxing.testlinkedlist2;
import java.util.Iterator;
import java.util.LinkedList;
public class TestLinkedListClass2 {
	public static void main(String[] args) {
		LinkedList  mylist=new LinkedList();
		//LinkedList类的常用实例方法
		//LinkedList类中的实例方法与ArrayList类中的实例方法相同
		//boolean	add(Object o) 将指定的元素追加到此列表的末尾。 
		mylist.add("hello");
		mylist.add(false);
		mylist.add(1234);
		mylist.add("hello");
		mylist.add(168.9);
		//int	size() 返回此列表中的元素数。 
		System.out.println("size=="+mylist.size());
		//boolean	contains(Object o) 如果此列表包含指定的元素，则返回 true 。 
		System.out.println("contains=="+mylist.contains("hello"));
		//Object 	get(int index) 返回此列表中指定位置的元素。
		System.out.println("get=="+mylist.get(2));
		//int	indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
		System.out.println("indexOf=="+mylist.indexOf("hello"));
		//int	lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。 
		System.out.println("lastIndexOf=="+mylist.lastIndexOf("hello"));
		//Object 	remove(int index) 删除该列表中指定位置的元素。 
		//boolean	remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）。 
		//Object 	set(int index, Object  element) 用指定的元素替换此列表中指定位置的元素。 
		System.out.println("get=="+mylist.get(3));
		mylist.set(3,"你好");
		System.out.println("get=="+mylist.get(3));
		//boolean	isEmpty() 如果此列表不包含元素，则返回 true 。
		System.out.println("isEmpty=="+mylist.isEmpty());
		//void	clear() 从列表中删除所有元素。
		//mylist.clear();
		//System.out.println("isEmpty=="+mylist.isEmpty());
		
		//多出一组对第一个元素和最后一个元素的操作方法
		//void	addFirst(Object e) 在该列表开头插入指定的元素。 
		//void	addLast(Object  e) 将指定的元素追加到此列表的末尾。
		mylist.addFirst("zhangsan");
		mylist.addLast("lisi");
		//使用普通的for循环遍历LinkedList
		for(int i=0;i<mylist.size();i++){
			System.out.println("普通的for循环---"+mylist.get(i));
		}
		//Object 	getFirst() 返回此列表中的第一个元素。 
		System.out.println("getFirst--"+mylist.getFirst());
		//Object 	getLast() 返回此列表中的最后一个元素。
		System.out.println("getLast--"+mylist.getLast());
		//Object 	removeFirst() 从此列表中删除并返回第一个元素。
		//Object 	removeLast() 从此列表中删除并返回最后一个元素。 
		mylist.removeFirst();
		mylist.removeLast();
		//使用增强的for循环遍历LinkedList
		for(Object obj:mylist){
			System.out.println("增强的for循环---"+obj);
		}
		//使用迭代器遍历LinkedList集合
		Iterator  iterator=mylist.iterator();
		while(iterator.hasNext()){
			Object obj=iterator.next();
			System.out.println("迭代器遍历集合---"+obj);
		} 
	}
}