在完成对C语言的学习后，我最近开始了对C++和Java的学习，目前跟着视频学习了一些语法，也跟着敲了一些代码，有了一定的掌握程度。现在将跟着视频做的笔记进行整理。本篇博客是整理Java知识点的第十八篇博客。
本篇博客介绍了Java的List集合。
本系列博客所有Java代码都使用IntelliJ IDEA编译运行，版本为2022.1。所用JDK版本为JDK11。
目录
List集合
List集合的概述和特点
List集合是有序集合（也称为序列），用户可以精确控制列表中每个元素的插入位置，用户可以通过索引访问元素。List集合允许重复的元素。
import java.util.ArrayList;
import java.util.List;
import java.util.Iterator;
public class listtest1 {
public static void main(String[] args){
List<String> test1 = new ArrayList<String>();
test1.add("Hello");
test1.add("Java");
Iterator<String> it1 = test1.iterator();
while(it1.hasNext()){
String s1 = it1.next();
System.out.println(s1);
}
List<String> test2 = new ArrayList<String>();
test2.add("Hahahahaha ");
test2.add("Hahahahaha ");
test2.add("Hahahahaha ");
Iterator<String> it2 = test2.iterator();
while(it2.hasNext()){
String s2 = it2.next();
System.out.println(s2);
}
}
}程序创建了两个集合。程序的输出是：
Hello
Java
Hahahahaha
Hahahahaha
Hahahahaha
List集合的特有方法
void add(int index,E e)在集合中索引为index的位置插入e。
E remove(int index)删除索引为index的元素，并将其返回。
E set(int index,E e)修改索引为index的元素，并将原内容返回。
E get(int index)返回索引为index的元素。
import java.util.ArrayList;
import java.util.List;
public class listtest2 {
public static void main(String[] args){
List<String> test = new ArrayList<String>();
test.add("Hello");
test.add("world");
test.add(1,"Java");
test.add(2,"and");
System.out.println(test);
System.out.println(test.remove("world"));
System.out.println(test.remove("and"));
System.out.println(test);
System.out.println(test.set(0,"hello"));
System.out.println(test.get(0));
System.out.println(test.get(1));
}
}
程序的输出是：
[Hello, Java, and, world]
true
true
[Hello, Java]
Hello
hello
Java
List集合存储学生对象并遍历
public class liststudent {
private String name;
private int age;
public liststudent(){}
public liststudent(String name,int age){
this.name = name;
this.age = age;
}
public void setname(String name){
this.name = name;
}
public String getname(){
return name;
}
public void setage(int age){
this.age = age;
}
public int getage(){
return age;
}
}这是要添加的学生类。
import java.util.ArrayList;
import java.util.List;
import java.util.Iterator;
public class listtest3 {
public static void main(String[] args){
liststudent s1 = new liststudent("Olaf",17);
liststudent s2 = new liststudent("Odette",18);
liststudent s3 = new liststudent("Nestor",25);
List<liststudent> test = new ArrayList<liststudent>();
test.add(s1);
test.add(s2);
test.add(s3);
int i;
for(i = 0; i < test.size(); i += 1){
liststudent temp = test.get(i);
System.out.println("The name is " + temp.getname());
System.out.println("The age is " + temp.getage());
}
System.out.println();
Iterator<liststudent> it = test.iterator();
while(it.hasNext()){
liststudent temp = it.next();
System.out.println("The name is " + temp.getname());
System.out.println("The age is " + temp.getage());
}
}
}程序用普通for循环和迭代器进行遍历。程序的输出是：
The name is Olaf
The age is 17
The name is Odette
The age is 18
The name is Nestor
The age is 25
The name is Olaf
The age is 17
The name is Odette
The age is 18
The name is Nestor
The age is 25
ListIterator
普通迭代器在遍历的过程中不能修改元素。
ListIterator是列表迭代器。通过List集合的listIterator方法得到，是List集合特有的。ListIterator允许程序员沿任一方向遍历列表，在遍历期间修改列表，获取列表中迭代器的当前位置。
使用ListIterator需要导包，import java.util.ListIterator
下面是ListIterator中的常用方法
E next()返回迭代中的下一个元素。
boolean hasNext()判断后面是否有更多元素，有则返回true。
E previous()返回迭代的上一个元素。
boolean hasPrevious()判断前面是否有更多元素，有则返回true。
void add(E e)将e插入列表。
import java.util.List;
import java.util.ArrayList;
import java.util.ListIterator;
public class listiterator {
public static void main(String[] args) {
List<String> test = new ArrayList<String>();
test.add("This");
test.add("is");
test.add("a");
test.add("test");
ListIterator<String> it = test.listIterator();
while(it.hasNext()){
String temp = it.next();
System.out.println(temp);
}
System.out.println();
while(it.hasPrevious()){
String temp = it.previous();
System.out.println(temp);
}
while(it.hasNext()){
String temp = it.next();
if(temp.equals("a")){
it.add("n important");
}
}
System.out.println(test);
}
}程序利用ListIterator进行从前向后和从后向前的遍历，然后在遍历中进行插入。程序的输出是：
This
is
a
test
test
a
is
This
[This, is, a, n important, test]
增强for循环
增强for循环可以简化数组和Collection集合的遍历，是JDK5后出现的。增强for循环的格式是：
for(元素数据类型 变量名:数组或Collection集合){
...
}
增强for循环内直接用括号里的变量名即可，变量就是元素。
public class strengthenfor {
public static void main(String[] args){
int[] arr = new int[]{1,2,3,4,5};
for(int i:arr){
System.out.println(i);
}
String[] str = new String[]{"Hello","world","hello","Java"};
for(String s:str){
System.out.println(s);
}
}
}程序使用增强for循环进行遍历，程序的输出是：
1
2
3
4
5
Hello
world
hello
Java
List集合存储学生对象
public class liststudentthird {
private String name;
private int age;
public liststudentthird(){
}
public liststudentthird(String name,int age){
this.name = name;
this.age = age;
}
public void setname(String name){
this.name = name;
}
public String getname(){
return name;
}
public void setage(int age){
this.age = age;
}
public int getage(){
return age;
}
}这是对应的学生类。
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class liststudentthirdtest {
public static void main(String[] args){
liststudentthird s1 = new liststudentthird("Peter",18);
liststudentthird s2 = new liststudentthird("Patricia",19);
liststudentthird s3 = new liststudentthird();
s3.setname("Gordon");
s3.setage(22);
List<liststudentthird> test = new ArrayList<liststudentthird>();
test.add(s1);
test.add(s2);
test.add(s3);
Iterator<liststudentthird> it = test.iterator();
while(it.hasNext()){
liststudentthird temp = it.next();
System.out.println("The name is " + temp.getname());
System.out.println("The age is " + temp.getage());
}
System.out.println();
int i;
for(i = 0; i < test.size(); i += 1){
liststudentthird temp = test.get(i);
System.out.println("The name is " + temp.getname());
System.out.println("The age is " + temp.getage());
}
System.out.println();
for(liststudentthird lst: test){
System.out.println("The name is " + lst.getname());
System.out.println("The age is " + lst.getage());
}
}
}
程序使用集合存储学生类，并通过迭代器，普通for循环和增强for循环进行遍历。程序的输出是：
The name is Peter
The age is 18
The name is Patricia
The age is 19
The name is Gordon
The age is 22
The name is Peter
The age is 18
The name is Patricia
The age is 19
The name is Gordon
The age is 22
The name is Peter
The age is 18
The name is Patricia
The age is 19
The name is Gordon
The age is 22
简单的数据结构简介
数据结构是计算机存储和组织数据的形式，是指相互之间存在一种或多种特定关系的数据元素的集合。合适的数据结构可以带来更高的效率。
栈是先进后出的数据结构，最先进去的最后出去。
队列是先进先出的数据结构，最先进去的最先出去。
链表的每个元素是结点，结点包含本身数据和下一个结点的地址。链表增删快，查询慢。
数组查询快，增删慢。
数据结构课会详细介绍栈、队列、链表、二叉树、图、哈希表等数据结构。
List集合子类特点
List集合常用子类为ArrayList和LinkedList。
ArrayList底层数据结构是数组，查询快，增删慢，LinkedList底层数据结构是链表，查询慢，增删快。
使用LinkedList需要导包，import java.util.LinkedList
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Iterator;
public class arraylinked {
public static void main(String[] args){
ArrayList<String> array = new ArrayList<String>();
array.add("Hello");
array.add("world");
array.add("Java");
Iterator<String> it1 = array.iterator();
while(it1.hasNext()){
String s = it1.next();
System.out.println(s);
}
System.out.println();
int i;
for(i = 0;i < array.size();i += 1){
String s = array.get(i);
System.out.println(s);
}
System.out.println();
for(String s:array){
System.out.println(s);
}
LinkedList<String> linked = new LinkedList<String>();
linked.add("Hello");
linked.add("world");
linked.add("Java");
System.out.println();
System.out.println();
Iterator<String> it2 = linked.iterator();
while(it2.hasNext()){
String s = it2.next();
System.out.println(s);
}
System.out.println();
int j;
for(j = 0; j < linked.size(); j += 1){
String s = linked.get(j);
System.out.println(s);
}
System.out.println();
for(String s:linked){
System.out.println(s);
}
}
}
程序使用ArrayList和LinkedList存储Hello world Java，都使用迭代器，普通for循环和增强for循环遍历。程序输出以下内容6次：
Hello
world
Java
ArrayList和LinkedList存储学生对象
public class arrayliststudenttest {
private String name;
private int age;
public arrayliststudenttest(){}
public arrayliststudenttest(String name,int age){
this.name = name;
this.age = age;
}
public void setname(String name){
this.name = name;
}
public String getname(){
return name;
}
public void setage(int age){
this.age = age;
}
public int getage(){
return age;
}
}这是测试ArrayList表示用的学生类。
import java.util.ArrayList;
import java.util.Iterator;
public class arraylisttest {
public static void main(String[] args){
ArrayList<arrayliststudenttest> test = new ArrayList<arrayliststudenttest>();
arrayliststudenttest alst1 = new arrayliststudenttest("Nestor",25);
arrayliststudenttest alst2 = new arrayliststudenttest("Nora",19);
arrayliststudenttest alst3 = new arrayliststudenttest();
alst3.setname("Ophelia");
alst3.setage(17);
test.add(alst1);
test.add(alst2);
test.add(alst3);
Iterator<arrayliststudenttest> it = test.iterator();
while(it.hasNext()){
arrayliststudenttest alst = it.next();
System.out.println("The name is " + alst.getname());
System.out.println("The age is " + alst.getage());
}
System.out.println();
int i;
for(i = 0; i < test.size();i += 1){
arrayliststudenttest alst = test.get(i);
System.out.println("The name is " + alst.getname());
System.out.println("The age is " + alst.getage());
}
System.out.println();
for(arrayliststudenttest alst:test){
System.out.println("The name is " + alst.getname());
System.out.println("The age is " + alst.getage());
}
}
}程序创建了三个arrayliststudenttest类对象，并存放至一个ArrayList集合中。随后用迭代器，普通for循环和增强for循环进行遍历。程序的输出是：
The name is Nestor
The age is 25
The name is Nora
The age is 19
The name is Ophelia
The age is 17
The name is Nestor
The age is 25
The name is Nora
The age is 19
The name is Ophelia
The age is 17
The name is Nestor
The age is 25
The name is Nora
The age is 19
The name is Ophelia
The age is 17
public class linkedliststudenttest {
private String name;
private int age;
public linkedliststudenttest(){}
public linkedliststudenttest(String name,int age){
this.name = name;
this.age = age;
}
public void setname(String name){
this.name = name;
}
public String getname(){
return name;
}
public void setage(int age){
this.age = age;
}
public int getage(){
return age;
}
}这是测试LinkedList表示的学生类。
import java.util.LinkedList;
import java.util.Iterator;
public class linkedlisttest {
public static void main(String[] args){
LinkedList<linkedliststudenttest> test = new LinkedList<linkedliststudenttest>();
linkedliststudenttest llst1 = new linkedliststudenttest("Nestor",25);
linkedliststudenttest llst2 = new linkedliststudenttest("Nora",19);
linkedliststudenttest llst3 = new linkedliststudenttest();
llst3.setname("Ophelia");
llst3.setage(17);
test.add(llst1);
test.add(llst2);
test.add(llst3);
Iterator<linkedliststudenttest> it = test.iterator();
while(it.hasNext()){
linkedliststudenttest llst = it.next();
System.out.println("The name is " + llst.getname());
System.out.println("The age is " + llst.getage());
}
System.out.println();
int i;
for(i = 0; i < test.size();i += 1){
linkedliststudenttest llst = test.get(i);
System.out.println("The name is " + llst.getname());
System.out.println("The age is " + llst.getage());
}
System.out.println();
for(linkedliststudenttest llst:test){
System.out.println("The name is " + llst.getname());
System.out.println("The age is " + llst.getage());
}
}
}程序创建了三个linkedliststudenttest类对象，并存放至一个ArrayList集合中。随后用迭代器，普通for循环和增强for循环进行遍历。程序的输出是：
The name is Nestor
The age is 25
The name is Nora
The age is 19
The name is Ophelia
The age is 17
The name is Nestor
The age is 25
The name is Nora
The age is 19
The name is Ophelia
The age is 17
The name is Nestor
The age is 25
The name is Nora
The age is 19
The name is Ophelia
The age is 17
LinkedList集合的特有功能
public void addFirst(E e)在该列表开头插入e。
public void addLast(E e)在该列表末尾加入e。
public E getFirst()返回第一个元素。
public E getLast()返回最后一个元素。
public E removeFirst()删除第一个元素，并将其返回。
public E removeLast()删除最后一个元素，并将其返回。
import java.util.LinkedList;
public class linkedlistmethod {
public static void main(String[] args){
LinkedList<String> test = new LinkedList();
test.add("Goni");
test.add("Vamco");
test.add("Molave");
System.out.println(test.getFirst());
System.out.println(test.getLast());
test.removeLast();
test.addLast("Rai");
test.addFirst("Phonfone");
test.removeFirst();
test.addFirst("Hagibis");
test.addFirst("Lekima");
System.out.println(test);
}
}程序的输出是：
Goni
Molave
[Lekima, Hagibis, Goni, Vamco, Rai]
296
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
