概念:顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。
目录
一、自定义顺序表
1.MyArrayList类
import java.util.Arrays;
public class MyArrayList implements IList {
private int[] elem;
private int usedSize;
public MyArrayList() {
this.elem = new int[10];
this.usedSize = 0;
}
@Override
public boolean isFull() {
return usedSize == elem.length;
}
@Override
public void add(int data) {
if(isFull()) {
resize();
}
elem[usedSize] = data;
usedSize++;
}
private void resize() {
elem = Arrays.copyOf(elem,2*elem.length);
}
@Override
public void display() {
for (int i = 0; i < usedSize; i++) {
System.out.print(elem[i] + " ");
}
System.out.println();
}
@Override
public void add(int pos, int data) {
if (pos < 0 || pos > usedSize) {
throw new PosOutOfException("pos位置不合法!");
}
if (isFull()) {
resize();
}
for (int i = usedSize; i > pos ; i--) {
//elem[pos+1] = elem[pos];
elem[i] = elem[i-1];
}
elem[pos] = data;
usedSize++;
}
@Override
public boolean contains(int toFind) {
for (int i = 0; i < usedSize; i++) {
if(elem[i] == toFind) {
return true;
}
}
return false;
}
@Override
public int indexOf(int toFind) {
for (int i = 0; i < usedSize; i++) {
if(elem[i] == toFind) {
return i;
}
}
return -1;
}
@Override
public int get(int pos) {
if(pos < 0 || pos > usedSize) {
throw new PosOutOfException("pos位置不合法！");
}
if(isEmpty()) {
return -1;
}
return elem[pos];
}
private boolean isEmpty() {
return usedSize == 0;
}
@Override
public void set(int pos, int value) {
if(pos < 0 || pos > usedSize) {
throw new PosOutOfException("pos位置不合法！");
}
elem[pos] = value;
}
@Override
public void remove(int toRemove) {
// for (int i = 0; i < usedSize; i++) {
// if(elem[i] == toRemove) {
// for (int j = i; j < usedSize - 1; j++) {
// //elem[usedSize-2] = elem[usedSize-1];
// elem[j] = elem[j+1];
// }
// usedSize--;
// return;
// }
// }
// System.out.println("没有你要删除的元素!");
int index = indexOf(toRemove);
if(index == -1) {
System.out.println("没有你要删除的元素!");
return;
}
for (int i = index; i < usedSize - 1; i++) {
//elem[usedSize-2] = elem[usedSize-1];
elem[i] = elem[i+1];
}
usedSize--;
}
@Override
public int size() {
return usedSize;
}
@Override
public void clear() {
usedSize = 0;
}
}2.IList接口
public interface IList {
//判断数组是否满了
boolean isFull();
// 新增元素,默认在数组最后新增
void add(int data);
//打印数组
void display();
// 在 pos 位置新增元素
void add(int pos, int data);
// 判定是否包含某个元素
boolean contains(int toFind);
// 查找某个元素对应的位置
int indexOf(int toFind);
// 获取 pos 位置的元素
int get(int pos);
// 给 pos 位置的元素设为 value
void set(int pos, int value);
//删除第一次出现的关键字key
void remove(int toRemove);
// 获取顺序表长度
int size();
// 清空顺序表
void clear();
}3.PosOutOfExcption类
public class PosOutOfException extends RuntimeException{
public PosOutOfException() {
}
public PosOutOfException(String message) {
super(message);
}
}
4.Text类
public class Text {
public static void main(String[] args) {
}
public static void main4(String[] args) {
MyArrayList myArrayList = new MyArrayList();
myArrayList.add(1);
myArrayList.add(2);
myArrayList.add(3);
myArrayList.add(4);
myArrayList.add(5);
myArrayList.add(6);
System.out.println(myArrayList.size());
myArrayList.clear();
myArrayList.display();
}
public static void main3(String[] args) {
MyArrayList myArrayList = new MyArrayList();
myArrayList.add(1);
myArrayList.add(2);
myArrayList.add(3);
myArrayList.add(4);
myArrayList.add(5);
myArrayList.add(6);
myArrayList.set(2,30);
myArrayList.display();
myArrayList.remove(4);
System.out.println();
myArrayList.display();
}
public static void main2(String[] args) {
MyArrayList myArrayList = new MyArrayList();
myArrayList.add(1);
myArrayList.add(2);
myArrayList.add(3);
System.out.println(myArrayList.indexOf(5));
System.out.println(myArrayList.get(5));
}
public static void main1(String[] args) {
MyArrayList myArrayList = new MyArrayList();
myArrayList.add(1);
myArrayList.add(2);
myArrayList.add(3);
myArrayList.display();
myArrayList.add(2,10);
System.out.println();
myArrayList.display();
boolean ret = myArrayList.contains(5);
System.out.println(ret);
}
}
二、Java中自带的顺序表
1.ArrayList简介
1.ArrayList是以泛型方式实现的，使用时必须要先实例化
2. ArrayList实现了RandomAccess接口，表明ArrayList支持随机访问
3. ArrayList实现了Cloneable接口，表明ArrayList是可以clone的
4. ArrayList实现了Serializable接口，表明ArrayList是支持序列化的
5. 和Vector不同，ArrayList不是线程安全的，在单线程下可以使用，在多线程中可以选择Vector或者CopyOnWriteArrayList
6. ArrayList底层是一段连续的空间，并且可以动态扩容，是一个动态类型的顺序表
2.ArrayLsit的使用
2.1ArrayList的构造
| 方法 | 解释 |
| ArrayList() | 无参构造 |
| ArrayList(Collection<? extends E> c) | 利用其他 Collection 构建 ArrayList |
| ArrayList(int initialCapacity) | 指定顺序表初始容量 |
import java.util.ArrayList;
class Book {
//~~~
}
public class Text {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(0);
list.add(1);
list.add(2);
list.add(3);
ArrayList<Book> booklist = new ArrayList<Book>();//书架
}
}2.2ArrayList的常见操作
| 方法 | 解释 |
| 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<E> subList(int fromIndex, int toIndex) | 截取部分 list |
boolean addAll(Collection<? extends E> c)：
public class Text {
public static void main(String[] args) {
ArrayList<Integer> list1 = new ArrayList<Integer>();
list1.add(1);
list1.add(2);
list1.add(3);
list1.add(4);
ArrayList<Integer> list2 = new ArrayList<Integer>();
list2.add(11);
list2.add(22);
list2.add(33);
list2.add(44);
//list2中的泛型要是list1泛型的子类
list1.addAll(list2);
System.out.println(list1);
}
}
//[1, 2, 3, 4, 11, 22, 33, 44]E remove(int index):
public class Text {
public static void main(String[] args) {
ArrayList<Integer> list1 = new ArrayList<Integer>();
list1.add(1);
list1.add(2);
list1.add(3);
list1.add(4);
list1.remove(1);
System.out.println("list1:" + list1);
ArrayList<Integer> list2 = new ArrayList<Integer>();
list2.add(1);
list2.add(2);
list2.add(3);
list2.add(4);
list2.remove(new Integer(1));//老版本
System.out.println("list2:" + list2);
}
}
//list1:[1, 3, 4]
//list2:[2, 3, 4]List<E> subList(int fromIndex, int toIndex):
public class Text {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
List<Integer> listTmp = list.subList(1,3);//截取[1,3)的值,返回的是[1,3)的地址,没有产生新对象
System.out.println(listTmp);
System.out.println("==============");
listTmp.set(0,99);
System.out.println("listTmp:" + listTmp);
System.out.println("list:" + list);
}
}
//[2, 3]
//==============
//listTmp:[99, 3]
//list:[1, 99, 3, 4]3.ArrayList的遍历
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class Text {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
System.out.println("======直接输出======");
System.out.println(list);
System.out.println("======for循环======");
for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i) + " ");
}
System.out.println();
System.out.println("======for each======");
for (Integer x : list) {
System.out.print(x + " ");
}
System.out.println();
System.out.println("======迭代器遍历1======");
Iterator list1 = list.iterator();
while(list1.hasNext()) {
System.out.print(list1.next() + " ");
}
System.out.println();
System.out.println("======迭代器遍历2======");
ListIterator list2 = list.listIterator();
while(list2.hasNext()) {
System.out.print(list2.next() + " ");
}
System.out.println();
System.out.println("======迭代器遍历3======");//从后往前
ListIterator listPrev = list.listIterator(list.size());
while(listPrev.hasPrevious()) {
System.out.print(listPrev.previous() + " ");
}
System.out.println();
}
//======直接输出======
//[1, 2, 3, 4]
//======for循环======
//1 2 3 4
//======for each======
//1 2 3 4
//======迭代器遍历1======
//1 2 3 4
//======迭代器遍历2======
//1 2 3 4
//======迭代器遍历3======
//4 3 2 1 4.ArrayList的扩容机制
1. 检测是否真正需要扩容，如果是调用grow准备扩容
2. 预估需要库容的大小，初步预估按照1.5倍大小扩容
如果用户所需大小超过预估1.5倍大小，则按照用户所需大小扩容真正扩容之前检测是否能扩容成功，防止太大导致扩容失败
3. 使用copyOf进行扩容
5.ArrayList的具体使用
5.1杨辉三角
class Solution1 {
public List<List<Integer>> generate(int numRows) {
List<List<Integer>> lists = new ArrayList<>();
for (int i = 0; i < numRows; i++) {
List<Integer> list = new ArrayList<>();
for (int j = 0; j < i; j++) {
if(i == 0||j == i) {
list.add(1);
}else {
list.add(lists.get(i-1).get(j) + lists.get(i-1).get(j-1));
}
}
lists.add(list);
}
return lists;
}
}5.2简单的洗牌算法
package dome1;
public class Card {
public String suit;
public int rank;
public Card(String suit, int rank) {
this.suit = suit;
this.rank = rank;
}
@Override
public String toString() {
return "{ " + suit + rank + " }";
}
}
package dome1;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public class Game {
public static final String[] SUITS = {"♥","♠","♦","♣"};
public List<Card> creatCard() {
List<Card> list =new ArrayList<>();
for (int i = 0; i < SUITS.length; i++) {
for (int j = 1; j <= 13; j++) {
String suit = SUITS[i];
Card card = new Card(suit,j);
list.add(card);
}
}
return list;
}
public void shuffle(List<Card> cardList) {
Random random = new Random();
for (int i = cardList.size()-1; i > 0; i--) {
int ret = random.nextInt(i);
swap(cardList,i,ret);
}
}
private void swap(List<Card> cardList,int i,int j) {
Card tmp = cardList.get(j);
cardList.set(j,cardList.get(i));
cardList.set(i,tmp);
}
public List<List<Card>> play(List<Card> cardList) {
List<List<Card>> head = new ArrayList<>();
List<Card> head0 = new ArrayList<>();
List<Card> head1 = new ArrayList<>();
List<Card> head2 = new ArrayList<>();
head.add(head0);
head.add(head1);
head.add(head2);
//每人揭5张牌
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 3; j++) {
Card card = cardList.remove(0);
head.get(j).add(card);
}
}
return head;
}
}
package dome1;
import java.util.List;
public class Text {
public static void main(String[] args) {
Game game = new Game();
List<Card> cardList = game.creatCard();
System.out.println("洗牌前：" + cardList);
System.out.println("====================");
game.shuffle(cardList);
System.out.println("洗牌后：" + cardList);
System.out.println("====================");
List<List<Card>> head = game.play(cardList);
for (int i = 0; i < head.size(); i++) {
System.out.println("第" + (i+1) + "个人的牌是：" + head.get(i));
}
System.out.println("剩下的牌是：" + cardList);
}
}
//洗牌前：[{ ♥1 }, { ♥2 }, { ♥3 }, { ♥4 }, { ♥5 }, { ♥6 }, { ♥7 }, { ♥8 }, { ♥9 }, { ♥10 }, { ♥11 }, { ♥12 }, { ♥13 }, { ♠1 }, { ♠2 }, { ♠3 }, { ♠4 }, { ♠5 }, { ♠6 }, { ♠7 }, { ♠8 }, { ♠9 }, { ♠10 }, { ♠11 }, { ♠12 }, { ♠13 }, { ♦1 }, { ♦2 }, { ♦3 }, { ♦4 }, { ♦5 }, { ♦6 }, { ♦7 }, { ♦8 }, { ♦9 }, { ♦10 }, { ♦11 }, { ♦12 }, { ♦13 }, { ♣1 }, { ♣2 }, { ♣3 }, { ♣4 }, { ♣5 }, { ♣6 }, { ♣7 }, { ♣8 }, { ♣9 }, { ♣10 }, { ♣11 }, { ♣12 }, { ♣13 }]
//====================
//洗牌后：[{ ♣11 }, { ♠5 }, { ♠7 }, { ♥9 }, { ♦5 }, { ♠8 }, { ♣7 }, { ♣5 }, { ♠4 }, { ♦12 }, { ♦6 }, { ♣3 }, { ♦3 }, { ♦1 }, { ♠1 }, { ♥7 }, { ♥10 }, { ♦10 }, { ♦7 }, { ♥12 }, { ♦8 }, { ♦2 }, { ♣10 }, { ♠12 }, { ♦11 }, { ♥5 }, { ♠3 }, { ♣4 }, { ♦9 }, { ♥3 }, { ♦4 }, { ♠6 }, { ♣1 }, { ♥8 }, { ♣13 }, { ♣8 }, { ♣9 }, { ♥1 }, { ♠13 }, { ♣6 }, { ♥13 }, { ♠9 }, { ♣12 }, { ♠2 }, { ♥4 }, { ♠11 }, { ♠10 }, { ♥11 }, { ♦13 }, { ♥2 }, { ♣2 }, { ♥6 }]
//====================
//第1个人的牌是：[{ ♣11 }, { ♥9 }, { ♣7 }, { ♦12 }, { ♦3 }]
//第2个人的牌是：[{ ♠5 }, { ♦5 }, { ♣5 }, { ♦6 }, { ♦1 }]
//第3个人的牌是：[{ ♠7 }, { ♠8 }, { ♠4 }, { ♣3 }, { ♠1 }]
//剩下的牌是：[{ ♥7 }, { ♥10 }, { ♦10 }, { ♦7 }, { ♥12 }, { ♦8 }, { ♦2 }, { ♣10 }, { ♠12 }, { ♦11 }, { ♥5 }, { ♠3 }, { ♣4 }, { ♦9 }, { ♥3 }, { ♦4 }, { ♠6 }, { ♣1 }, { ♥8 }, { ♣13 }, { ♣8 }, { ♣9 }, { ♥1 }, { ♠13 }, { ♣6 }, { ♥13 }, { ♠9 }, { ♣12 }, { ♠2 }, { ♥4 }, { ♠11 }, { ♠10 }, { ♥11 }, { ♦13 }, { ♥2 }, { ♣2 }, { ♥6 }]
扫一扫
1655
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
