List(线性表)
方法 | 解释 |
---|---|
boolean add(E e) | 尾插 e |
void add(int index, E element) | 将 e 插入到 index 位置 |
boolean addAll(Collection extends E> 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() | 无参构造 |
ArrayList(Collection extends E> c) | 利用其它 Collection 构造 ArrayList |
ArrayList(int initialCapacity) | 指定顺序表初始容量 |
LinkedList(链表)
方法 | 解释 |
---|---|
LinkedList() | 无参构造 |
List<Integer> list1 = new ArrayList<>();
list1.add(111);
list1.add(1,222);
list1.add(0,333);
List<Integer> list2 = new ArrayList<>();
list2.add(1);
list2.add(2);
list2.addAll(list1);
// list2.remove(0);
// list2.remove(4);
// System.out.println(list1);
// System.out.println(list2);
List<String> list3 = new ArrayList<>();
list3.add("111");
list3.add("222");
list3.add("333");
// list3.remove("111");
// System.out.println(list3.get(0));
// list3.set(0,"one");
// list3.clear();
// System.out.println(list3.contains("222"));
// System.out.println(list3.indexOf("333"));
// System.out.println(list3.lastIndexOf("333"));
List<String> list4 = list3.subList(1, 2);
list4.set(0,"2");
System.out.println(list4);
System.out.println(list3);
注意事项:
使用 subList 方法截取的部分 list,如果去修改,会影响到原来的数据和截取的数据。
因为 subList 方法只是生成一个引用,去指向你参数划分的范围。
List<Integer> list1 = new ArrayList<>();
list1.add(1);
list1.add(2);
list1.add(3);
list1.add(4);
List<Integer> list2 = list1.subList(1, 2);
System.out.println("修改前:" + list1);
list2.set(0,777);
System.out.println("截取修改后:" + list1);
//运行结果
修改前:[1, 2, 3, 4]
截取修改后:[1, 777, 3, 4]
//无参构造
List<Integer> list1 = new ArrayList<>();
//利用其它 Collection 构建 ArrayList
List<Integer> list2 = new ArrayList<>(list1);
//指定顺序表初始容量
List<Integer> list3 = new ArrayList<>(10);
LinkedList 底层代码其实是一个双向链表。
//无参构造方法
List<String> list1 = new LinkedList<>();
//利用其它 Collecttion 构建 ArrayList
List<String> list2 = new LinkedList<>(list1);
当你只是List
这个时候,ArrayList 的大小是 0。
在你第一次使用 add 方法的时候,源码底层最终会找到 grow 扩容函数,初始值就变成 10 了。
如果这 10 容量使用满,那么它就会扩容,方式是 1.5 倍扩容!!!
第一道:
创建若干学生对象(学生对象放在一个 List 中),
每个学生有一个姓名(String)、班级(String)和考试成绩属性(double)。
某次考试结束后,每个学生都获得了一个考试成绩。遍历 list 集合,并且把学生对象的属性打印出来。
class Student{
private String name;
private String classes;
private double score;
public Student(String name, String classes, double score) {
this.name = name;
this.classes = classes;
this.score = score;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getClasses() {
return classes;
}
public void setClasses(String classes) {
this.classes = classes;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", classes='" + classes + '\'' +
", score=" + score +
'}';
}
}
public static void main(String[] args) {
List<Student> list = new ArrayList<>();
list.add(new Student("林逸","19",88));
list.add(new Student("楚梦瑶","19",95));
list.add(new Student("陈雨舒","18",97));
for (Student s : list) {
System.out.println(s);
}
}
}
第二道:
删除第一个字符串中出现的第二个字符串中的字符。
例如:
String str1 = "welcome to it";
String str2 = "come";
输出结果:
wl t it
public static void main(String[] args) {
String str1 = "welcome to it";
String str2 = "come";
List<Character> list = new ArrayList<>();
for (int i = 0; i < str1.length(); i++) {
char ch = str1.charAt(i);
if (!str2.contains(ch + "")) {
list.add(ch);
}
}
for (Character c : list) {
System.out.print(c);
}
}
第三道:
有一个 List 当中存放的是整形数据,要求使用 Collections.sort 对 List 进行排序。
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(9);
list.add(8);
list.add(4);
list.add(5);
Collections.sort(list);
System.out.println(list);
}
程序能生成一副牌,一共 52 张,算四种花色(♠ ♥ ♣ ♦),不算大小王。
程序能洗牌,将 52 张牌洗乱。
程序能发牌,三个人依次发五张牌,还能查看剩余的牌数。
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
class Card {
public int rank; //牌面值
public String suit; //花色
@Override
public String toString() {
return String.format("[%s %d]", suit, rank);
}
}
public class CardDemo {
public static final String[] SUITS = {"♠", "♥", "♣", "♦"};
//生成一副牌
private static List<Card> buyDeck() {
List<Card> deck = new ArrayList<>(52);
for (int i = 0; i < 3; i++) {
for (int j = 1; j <= 13; j++) {
String suit = SUITS[i];
int rank = j;
Card card = new Card();
card.rank = rank;
card.suit = suit;
deck.add(card);
}
}
return deck;
}
//换牌
private static void swap(List<Card> deck, int i, int j) {
Card tmp = deck.get(i);
deck.set(i,deck.get(j));
deck.set(j,tmp);
}
//洗牌
private static void shuffle(List<Card> deck) {
Random random = new Random();
for (int i = deck.size() - 1; i > 0; i--) {
int r = random.nextInt(i);
swap(deck, i, r);
}
}
public static void main(String[] args) {
List<Card> deck = buyDeck();
System.out.println("刚刚生成的牌:");
System.out.println(deck);
shuffle(deck);
System.out.println("洗牌后:");
System.out.println(deck);
//发牌
List<List<Card>> hands = new ArrayList<>();
hands.add(new ArrayList<>());
hands.add(new ArrayList<>());
hands.add(new ArrayList<>());
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 3; j++) {
hands.get(j).add(deck.remove(0));
}
}
System.out.println("剩余的牌");
System.out.println(deck);
System.out.println("A 手中的牌");
System.out.println(hands.get(0));
System.out.println("B 手中的牌");
System.out.println(hands.get(1));
System.out.println("C 手中的牌");
System.out.println(hands.get(2));
}
}
给定一个非负整数 numRows,生成杨辉三角的前 numRows 行。
在杨辉三角中,每个数是它左上方和右上方的数的和。
import java.util.ArrayList;
import java.util.List;
public class Solution {
public static List<List<Integer>> generate(int numRows) {
List<List<Integer>> ret = new ArrayList<>();
//第一行随便存储个1
List<Integer> list1 = new ArrayList<>();
list1.add(1);
ret.add(list1);
//从第二行开始计算
for (int i = 1; i < numRows; i++) {
List<Integer> cur = new ArrayList<>();
//每行开始第一个元素都是 1
cur.add(1);
//计算中间的数据
for (int j = 1; j < i; j++) {
// cur.add(ret.get(i-1).get(j-1) + ret.get(i-1).get(j));
List<Integer> list = ret.get(i - 1);
int val = list.get(j) + list.get(j-1);
cur.add(val);
}
//每行最后一个元素都是 1
cur.add(1);
ret.add(cur);
}
return ret;
}
public static void main(String[] args) {
List<List<Integer>> lists = generate(5);
for (List<Integer> list : lists) {
System.out.println(list);
}
}
}