List------数据结构

1.Collection与Collections的区别？

1)Collection是一个集合接口。它提供了对集合对象进行基本操作的通用接口方法。实现该接口的类主要有List和Set，该接口的设计目标是为了各种具体的集合提供最大化的统一的操作方式。
2)Collections是针对集合类的一个包裹类，它提供了一系列静态方法实现对各种集合的搜索、排序以及线程安全化等操作

reverse(List list):反转list中的顺序，sort(List list):对list中的顺序进行自然排序，升序
   List<Integer> list=new ArrayList<>();System.out.println(list);  list.add(1);list.add(2);list.add(3);Collections.swap(list,1,2);
2.object的常见方法

clone(),toString(),equals(),hashcode(),wait,notify(),notifyAll()

1)实现了listIterator接口和Iterator接口，可以用迭代器来进行打印；

   List<String> list=new ArrayList<>();list.add("123");list.add("456");list.add("hello");ListIterator<String> sb=list.listIterator();while(sb.hasNext()){System.out.println(sb.next());}
我们也可以通过for循环的方式或者for each的方式来进行打印List<String> list=new ArrayList<>();list.add("123");list.add("456");list.add("789");for(String x:list){System.out.println(x);}System.out.println(list);for(int i=0;i<list.size();i++){System.out.println(list.get(i));}

2)我们在使用remove()方法的时候要注意什么?

 List<String> list=new ArrayList<>();list.add("abc");list.add("cde");list.add("hello");Iterator<String> it= list.iterator();while(it.hasNext()){it.remove();//这么使用IllegalException异常,因为此时it没有进行调用任何next()方法,此时it的指向是空System.out.println(it.next());}
//上面写法错误
while(it.hasNext())
{String ret= it.next();//先进行获取到第一个元素if(ret.equals("hello")){it.remove();}else{System.out.println(it.next());}
}

其实本质上来说 ListIterator接口也实现了Iterator接口

Iterator和ListIterator主要区别有：
一、ListIterator有add()方法(这个add方法会自动放到add(A)，就是放到A的后面)，remove()方法，可以向List中添加对象，而Iterator不能。

二、ListIterator和Iterator都有hasNext()和next()方法，可以实现顺序向后遍历。但是ListIterator有hasPrevious()和previous()方法，可以实现逆向(顺序向前)遍历。Iterator就不可以。也就是说Iterator是单向的，而ListIterator是双向的。IListIterator继承自Iterator。
while(it.hasPrevious()){
String str = it.previous();
System.out.print(str+” ");
}
三、都可实现删除对象，但是ListIterator可以实现对象的修改，set()方法可以实现。Iterator仅能遍历，不能修改。因为ListIterator的这些功能，可以实现对LinkedList等List数据结构的操作。

注意:

hasNext() :此方法用来判断迭代器对象指向的索引位置有没有元素

next() :获取迭代器对象当前索引位置的元素并将索引下标移至下一个元素

3)在调用remove()方法的时候，搭配迭代器进行使用的时候，应先通过next()方法来进行获取到迭代器中的元素，再根据我们所指定的条件进行删除，否则上面的代码可能会出现java.lang.lllegalStateException异常

boolean add---->进行尾插，List的add()方法是默认放到数组最后一个位置
add(int index,E element),把E插到index位置,把其他的元素都挪开
boolean addAll(Collection<? extends E> c)尾插c中的元素,放一个List
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 latIndexOf(Object o)返回最后一个o所在的下标
List subList(int fromindex,int toindex)进行截取,返回的是一个新的List

说明:

ArrayList实现了RandomAccess接口，表明ArrayList支持随机访问
ArrayList实现了Cloneable接口，表明ArrayList是可以clone的
ArrayList实现了Serializable接口，表明ArrayList是支持序列化的(把一个对象转化成字符串)
ArrayList不是线程安全的，在单线程下可以使用
ArrayList底层是一段连续的空间，并且可以动态扩容，是一个动态类型的顺序表
ArrayList中插入或删除一个元素需要移动其他元素，所以不适合在插入和删除操作频繁的场景下使用
 public static void main(String[] args) {List<String> list=new ArrayList<>();list.add("hello");list.add("world");list.add("生命在与运动");ListIterator<String> iterator= list.listIterator();while(iterator.hasNext()){String str=iterator.next();if(str.equals("hello")){iterator.add("lijiawei");}else{System.out.println(str);}}System.out.println(list);}
打印结果:world
生命在与运动
[hello, lijiawei, world, 生命在与运动]
但是如果说代码改成这样:
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;public class Test {public static void main(String[] args) {List<String> list=new ArrayList<>();list.add("hello");list.add("world");list.add("生命在与运动");ListIterator<String> iterator= list.listIterator();while(iterator.hasNext()){String str=iterator.next();if(str.equals("hello")){list.add("lijiawei");}else{System.out.println(str);}}System.out.println(list);}
}
程序会出现报错:Exception in thread "main" java.util.ConcurrentModificationException
当我们将ArrayList换成CpoyOnWriteArrayList上面的报出异常的错误代码就不会报错

1)add方法(int index,E element)

1.1)先进行检查下标的合法性,通过调用rangeCheckForAdd(index)方法

1.2)index合法之后，再进行确认一下真实的容量

1.3)在进行调用System.arraycpoy方法对数字进行拷贝，移动元素

1.4)存放index元素(array[index]=element，index++)
  public void add(int index, E element) {rangeCheckForAdd(index);//1.先进行检查下标合法性ensureCapacityInternal(size + 1);  //2.检查容量System.arraycopy(elementData, index, elementData, index + 1,size - index);//3.拷贝元素,增加的话向数组后面进行拷贝elementData[index] = element;//4存放元素size++;}
2)add(E element)

先进行确认容量，再将增加的元素放到最后一个位置
  public boolean add(E e) {ensureCapacityInternal(size + 1);  //确定是否进行扩容elementData[size++] = e;return true;}
3)E e=remove(int index)

3.1)先把你要删除的元素进行存储

3.2)计算要移动的元素个数，移动元素

3.3)最后一个位置置空
  public E remove(int index) {rangeCheck(index);//先进行检查元素的范围modCount++;E oldValue = elementData(index);//保存你要进行删除的元素,方便后面进行返回int numMoved = size - index - 1;//计算要进行移动的元素个数if (numMoved > 0)System.arraycopy(elementData, index+1, elementData, index,numMoved);//调用这个方法进行移动元素elementData[--size] = null; // clear to let GC do its work//将最后一个位置置为空return oldValue;}
4)remove(E element)删除具体的元素:元素是空也让你删
 public boolean remove(Object o) {if (o == null) {for (int index = 0; index < size; index++)if (elementData[index] == null) {fastRemove(index);return true;}} else {for (int index = 0; index < size; index++)if (o.equals(elementData[index])) {fastRemove(index);return true;}}return false;}
5)get方法:
 public E get(int index) {rangeCheck(index);//先进行检查数组的下标是否合法return elementData(index);//在进行取出元素返回}E elementData(int index) {return (E) elementData[index];}//自动转化成E类型
6)sublist方法:直接截取对应的下标的地址给新的List
 public static void main(String[] args) {List<String> list=new ArrayList<>();list.add("a");list.add("b");list.add("c");list.add("d");List<String> arraylist=list.subList(1,3);System.out.println("_______________________");arraylist.set(1,"l");System.out.println(list);System.out.println(arraylist);}
打印结果是:
[a, b, l, d]
[b, l]

4)ArrayLIst的扩容机制

1）当new ArrayList<>()没有指定容量大小的时候，底层虽然是数组，但是数组的大小是0;

2)当第一次add的时候，整个顺序表的长度才变成了10，当这10个位置放满了之后，就开始进行扩容，每次以当前长度1.5倍进行扩容

3)如果当前在构造方法中指定容量,那么顺序表的大小就是给定容量的大小,如果放满了，还是以1.5倍进行扩容;

4)List的ToString方法是实现在AbstractCollcetion里面的

5)ArrayList的构造方法

1)ArrayLIst();无参数进行构造

2)ArrayList(Collection <? extends E> c)利用其它的Collection来对ArrayList来进行构造

3)ArrayList(int index),根据顺序表来进行指定容量
List<String> list1=new ArrayList<>();
list1.add("123");
list1.add("456");
List<String> list2=new ArrayList<>(list1);
System.out.println(list2);
tolowerCase是返回了一个新的对象,java中由编译器自动导入,而不需要手动import导入的包是java.lang,以.java为后缀的源文件,只能有一个与源文件相同的类,可以包含其他类;
现在我们来进行实现一个ArrayList:

练习题一：输入:str1=abcqweracb 输出:abcqwer

1)先创建出一个StringBuilder对象,再进行遍历str这个字符串里面的字符,如果里面有str1中的字符，就不会进行拼接，如果没有，就进行拼接；但是仍然要注意一个事情，2)StringBuilder没有contains方法，contains方法里面的内容必须是字符串

3)这是不能够使用HashSet的，因为要按照字母的顺序来进行输出

4)我们利用哈希的思想，我们定义一个找整型数组，来进行标记这个字符是否出现过，出现过就把它对应的下标的值变成1，下次同样的字符来了之后，只要不是0就不是我想要的

5)因为题目中给的都是大写字母和小写字母，ASCILL码表范围就是65-122

hasNext()方法会判断接下来是否有非空字符.如果有,则返回true,否则返回false
hasNextLine() 方法会根据行匹配模式去判断接下来是否有一行(包括空行),如果有,则返回true,否则返回false
比如前面用hasNextLine()，那么后面要用 nextLine() 来处理输入;

 public static void main(String[] args) {Scanner scan=new Scanner(System.in);String str=scan.next();StringBuilder sb=new StringBuilder();for(int i=0;i<str.length();i++){    char ch=str.charAt(i);if(!sb.toString().contains(ch+"")){sb.append(ch);}}System.out.println(sb.toString());}

1)这个题本质上就是一个去重操作，这里面的数组下表就相当于是字符对应的ASCILL码表，数组下标的值就相当于这个元素出现了几次

2)我们遍历这个字符串，如果发现他的数组下表对应的元素是0，那么直接拼接到

3)stringBuilder里面，并将数组下标的值进行加加

不是0那么说明之前出现过，就不用管了

  public static void main(String[] args) {Scanner scan=new Scanner(System.in);String str= scan.next();StringBuilder builder=new StringBuilder();int[] array=new int[58];for(int i=0;i<str.length();i++){char ch=str.charAt(i);if(array[ch-65]==0){//说明此时是第一次出现builder.append(ch);array[ch-65]=1;}else{array[ch-65]++;}}System.out.println(builder);}

练习题二:一个学校中有若干学生(学生对象放在一个List中，每一个学生有一个姓名，班级，和考试成绩的属性，某次考试成绩结束之后，每一个学生都获得了一个考试成绩.遍历List集合,把每一个学生对象的属性都打印出来；

List是可以存放自定义类型的
class Student{String name;String classes;double score;public Student(String name, String classes, double score) {this.name = name;this.classes = classes;this.score = score;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", classes='" + classes + '\'' +", score=" + score +'}';}
}
class test {public static void main(String[] args) {List<Student> list=new ArrayList<>();list.add(new Student("bit1","java100",90.3));list.add(new Student("bit2","java101",100.5));list.add(new Student("bit3","java102",31.7));System.out.println(list);}

List<String> list1=new ArrayList<>();

ArrayList<String> list2=new ArrayList<>();

上面两种方法有什么区别呢？

1)此时list1可使用的方法没有list2可使用的方法多，当借口引用引用实例化对象的时候，只能调用接口中特有的方法，不能调用ArrayList本身包含的(特有的方法)

2)也就是说父类引用引用子类对象，只能通过父类引用调用我们父类自己的方法(除非重写)，不能调用子类的

练习题三:删除第一个字符串中出现的第二个字符串中的字符；例如 String str1=" welcome to bit"; String str2="come" 输出的结果是wl t bit

我们可以使用一个集合类list来进行操作,我们使用for循环进行循环遍历str1中的字符串中的字符，如果str2不包含着这个字符，那么就可以把这个放到List中，最终打印我的这个List即可

在这里面我们要注意一个事情,contains(里面放的是字符串类型而不是字符类型)
String str1="welcome to bit";String str2="come";ArrayList<Character> list=new ArrayList<>();for(int i=0;i<str1.length();i++){   char ch=str1.charAt(i);if(!str2.contains(ch+"")){list.add(ch);}}System.out.println(list);}
//我们在这里面直接进行遍历str1中的字符串的字符,如果这个字符在str2中出现过,那么就进行舍弃,否则直接拼接到StringBulider里面public static void main(String[] args) {String str1="welcome to bit";String str2="come";StringBuilder stringBuiler=new StringBuilder();for(int i=0;i<str1.length();i++){char ch=str1.charAt(i);if(!str2.contains(ch+"")){stringBuiler.append(ch);}}System.out.println(stringBuiler.toString());}

练习题四:有一个List当前存放的是整形的数据，运用Collections.sort对list进行排序

 ArrayList<Integer> list=new ArrayList<>();list.add(10);list.add(11);list.add(7);Collections.sort(list);System.out.println(list);

练习题五:实现一个扑克牌的功能

构建一副扑克牌:每一张牌是由数字和花色构成的

揭牌:

1)一张扑克牌就是一个对象，我们使用Card对象来进行描述一张牌，那么一副牌我们就用一个ArrayList来进行表示

2)我们在进行创建一个类，通过BuyCard方法来进行买一符牌，生成一副牌，我们还要创建一个List表来存放所有的扑克牌

3)洗牌的过程:假设我有100张牌，我想洗最后一张牌，就随机生成前面的一张牌进行交换，我从后面向前面进行遍历,我可以Random random=new Random();

从数组的最后一个位置开始逐渐向前遍历，现在得到位置是index，就随机生成0-index数组下标的牌进行交换

int index=random.nextInt(100),我想办法生成一个0-100的下标，将这个100的下标与前面的牌进行交换；

4)如果从前面向后进行交换，后面下标的值是没有办法确定的

nextInt(a)----->[0,a]

class Card{private int rank;private String suit;public Card(int rank,String suit){this.rank=rank;this.suit=suit;}public String toString(){return "[数值是"+rank+" "+"花色是"+suit+"]";}}
class Box{private static final String[] suits={"♥","♠","♣","♦"};public static List<Card> BuyCard(){    List<Card> desk=new ArrayList<>();//我们接下来想用两层循环做到每一个花色生成13张牌for(int i=0;i<4;i++)//外层循环表示花色,i是可以从0下标开始进行的,因为他这个下标的意义是去除数组里面的元素{for(int j=1;j<=13;j++)//内层循环循环每一种花色的数字{String suit=suits[i];int rank=j;Card card=new Card(rank,suit);desk.add(card);//设置属性,构造牌，并把排放到list里面}}return desk;}//下一个方法我们要进行洗牌,使用洗牌的这个方法的时候,我们要把List传递过去
才可以进行正式的洗牌public static void xipai(List<Card> desk){  int len=desk.size();for(int i=len-1;i>0;i--){Random random=new Random();int index=random.nextInt(i);swap(desk,index,i);}}public static void swap(List<Card> list,int index,int i){Card temp=list.get(i);list.set(i,list.get(index));list.set(index,temp);}
}public static void main(String[] args) {
//下面是测试方法TestDemo demo=new TestDemo();List<Card> list=demo.BuyCards();demo.xipai(list);System.out.println(list);}

在下面我们还要实现揭牌和玩牌的操作

1)一共有三个人，每一个人要轮流揭5张牌,我们把每一个人所揭的牌都放到一个List数组里面

2）我们在实现一个List<List<card>>来方便进行管理

4)拿到Box里面的牌,调用remove(0)方法即可，就可以移除张牌了，因为每一个人揭一张牌，就相当于删掉了一张牌，况且我们每一次进行揭牌的时候，都是拿的最上面的一张牌，也就是0下标的牌

   List<Card> list=Box.BuyCard();System.out.println("开始进行买牌");System.out.println("开始进行洗牌");Box.xipai(list);System.out.println("开始进行玩牌和揭牌");List<Card> hand1=new ArrayList<>();//第一个人揭的牌就放在这个list数组里面List<Card> hand2=new ArrayList<>();//第二个人揭的牌就放在这个list数组里面List<Card> hand3=new ArrayList<>();//第三个人揭的牌就放在这个list数组里面List<List<Card>> fatherList=new ArrayList<>();//一会揭牌的时候看看该轮到那个人进行揭牌了hand.add(hand1);hand.add(hand2);hand.add(hand3);for(int i=0;i<5;i++)//三个人论流揭牌5张{for(int j=0;j<3;j++){Card card=list.remove(i);fatherList.get(j).add(card);}}System.out.println("第一个人的牌"+hand1);System.out.println("第二个人的牌"+hand2);System.out.println("第三个人的牌"+hand3);System.out.println("剩下的牌"+list);}
//上面的循环不可以写成这样
for(int i=0;i<3;i++){
for(int j=0;j<5;j++){
}
}
//这就表示每一个人一下子揭5张牌

练习题六:实现一个杨辉三角

1
1 2 1
1 3 3 1
1 4 6 4 1
arr1[i][j]=arr1[i-1][j-1]+arr1[i-1][j],我们可以把每一行看成一个List

class Solution{

public List<List<Integer>> generate(int numrows){

}

先以数组的方式来进行计算arr1[i][j]=arr1[i][j-1]+arr1[i][j]

我们计算的下标都是按照0来进行计算的

 public static void main(String[] args) {Scanner scanner=new Scanner(System.in);int n= scanner.nextInt();List<List<Integer>> ret=new ArrayList<>();List<Integer> list1=new ArrayList<>();//1我们先进行处理第一行list1.add(1);ret.add(list1);//到这里面我们才处理完杨辉三角的第一行for(int i=1;i<n;i++)//现在外层循环用来处理每一行{//每一行的第一个数字都是1,所以下面处理的是每一行的第一个数字List<Integer> list=new ArrayList();list.add(1);List<Integer> prev=ret.get(i-1);for(int j=1;j<i;j++){int num=prev.get(j)+prev.get(j-1);list.add(num);}//处理每一行的结尾list.add(1);ret.add(list);}System.out.println(ret);}

如何实现对List集合进行去重？

1)自定义去重:我们在这里面使用两个数组

通过循环判断当前的元素是否存在多个，如果存在多个那么删除此重复项

注意这里面的contains方法默认比较的是地址，也就是看是否指向同一个对象，“使用 List的contains方法用于判断对象是否存在于列表中

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;public class HelloWorld {static class Student{public String username;public int age;public Student(String username, int age) {this.username = username;this.age = age;}@Overridepublic String toString() {return "Student{" +"username='" + username + '\'' +", age=" + age +'}';}@Overridepublic boolean equals(Object obj) {Student o=(Student)obj;return (this.age==o.age)&&(this.username==o.username);}}public static void main(String[] args) {List<Student> list=new ArrayList<>();Student student1=new Student("李佳伟",10);Student student2=new Student("李嘉欣",11);Student student3=new Student("李嘉诚",12);Student student4=new Student("李佳伟",10);list.add(student1);list.add(student2);list.add(student3);list.add(student4);Iterator<Student> It=list.iterator();List<Student> newList=new ArrayList<>(list.size());while(It.hasNext()){Student student= It.next();if(!newList.contains(student)){//如果新集合中不存在,就进行添加newList.add(student);}}System.out.println(newList);}
}

2)使用HashSet来进行去重，但是元素的顺序发生了变化，所以可以使用LinkedHashSet来进行去重，注意我们在这里面需要重写hashcode和equals方法，否则会导致去重失败

import java.util.*;public class HelloWorld {static class Student{public String username;public int age;public Student(String username, int age) {this.username = username;this.age = age;}@Overridepublic String toString() {return "Student{" +"username='" + username + '\'' +", age=" + age +'}';}@Overridepublic int hashCode() {return Objects.hash(username, age);}@Overridepublic boolean equals(Object obj) {Student o=(Student)obj;return (this.age==o.age)&&(this.username==o.username);}}public static void main(String[] args) {List<Student> list=new ArrayList<>();Student student1=new Student("李佳伟",10);Student student2=new Student("李嘉欣",11);Student student3=new Student("李嘉诚",12);Student student4=new Student("李佳伟",10);list.add(student1);list.add(student2);list.add(student3);list.add(student4);Iterator<Student> It=list.iterator();LinkedHashSet<Student> set=new LinkedHashSet<>();while(It.hasNext()){Student student= It.next();set.add(student);}System.out.println(set);}
}

3)看看首次出现的位置和最后出现的位置是否相同:

import java.util.*;public class HelloWorld {static class Student{public String username;public int age;public Student(String username, int age) {this.username = username;this.age = age;}@Overridepublic String toString() {return "Student{" +"username='" + username + '\'' +", age=" + age +'}';}@Overridepublic int hashCode() {return Objects.hash(username, age);}@Overridepublic boolean equals(Object obj) {Student o=(Student)obj;return (this.age==o.age)&&(this.username==o.username);}}public static void main(String[] args) {List<Student> list=new ArrayList<>();Student student1=new Student("李佳伟",10);Student student2=new Student("李嘉欣",11);Student student3=new Student("李嘉诚",12);Student student4=new Student("李佳伟",10);list.add(student1);list.add(student2);list.add(student3);list.add(student4);Iterator<Student> It=list.iterator();while(It.hasNext()){Student student=It.next();if(list.indexOf(student)!=list.lastIndexOf(student)){It.remove();}}System.out.println(list);}
}

4)使用JAVA8的新特性Stream进行去重:

import java.util.*;
import java.util.stream.Collectors;public class HelloWorld {static class Student{public String username;public int age;public Student(String username, int age) {this.username = username;this.age = age;}@Overridepublic String toString() {return "Student{" +"username='" + username + '\'' +", age=" + age +'}';}@Overridepublic int hashCode() {return Objects.hash(username, age);}@Overridepublic boolean equals(Object obj) {Student o=(Student)obj;return (this.age==o.age)&&(this.username==o.username);}}public static void main(String[] args) {List<Student> list=new ArrayList<>();Student student1=new Student("李佳伟",10);Student student2=new Student("李嘉欣",11);Student student3=new Student("李嘉诚",12);Student student4=new Student("李佳伟",10);list.add(student1);list.add(student2);list.add(student3);list.add(student4);list=list.stream().distinct().collect(Collectors.toList());System.out.println(list);}
}

List------数据结构相关推荐

数据结构（08）— 线性单链表基本操作
1. 线性单链表数据结构 // 假定每个结点的类型用 SNode 表示 typedef struct SNodeTag {int data; // 所存储的数据元素SNodeTag *next; // ...
数据结构（06）— 线性循环链表实战
1. 循环链表定义单链的循环链表结点的存储结构和单链表的存储结构一样, 所不同的是: 最后一个结点的 next 域指向头结点, 而不是"空".这样, 由表尾很容易找到表头. 但若 ...
数据结构（05）— 线性单链表实战
1. 设计思路本项目的实质是完成对考生信息的建立.查找.插入.修改.删除等功能,可以首先定义项目的数据结构,然后将每个功能写成一个函数来完成对数据的操作,最后完成主函数以验证各个函数功能并得出运行结 ...
数据结构（04）— 线性顺序表实战
1. 设计思路本实战的实质是完成对学生成绩信息的建立.查找.插入.修改.删除等功能,可以首先定义项目的数据结构,然后将每个功能写成一个函数来完成对数据的操作,最后完成主函数以验证各个函数功能并得出运 ...
数据结构（03）— 数据处理基本操作（数据的查找、新增、删除、修改）
我们先来看一个关于查找的例子.查找,就是从复杂的数据结构中,找到满足某个条件的元素.通常可从以下两个方面来对数据进行查找操作: 根据元素的位置或索引来查找: 根据元素的数值特征来查找. 针对上述两种 ...
数据结构（02）— 时间复杂度与空间复杂度转换
1. 时间复杂度转化为空间复杂度常用的降低时间复杂度的方法有递归.二分法.排序算法.动态规划等,降低空间复杂度的核心思路就是,能用低复杂度的数据结构能解决问题,就千万不要用高复杂度的数据结构. ...
OpenCV 笔记（09）— 常用的数据结构和函数（Vec、Point、Scalar、Size、Rect、cvtColor）
1. Vec 对象类型 Vec 是一个主要用于数值向量的模板类.我们可以定义向量的类型和组件的数量: Vec<double, 19> myVector 我们还可以使用任何的预定义类型: t ...
数据结构与算法——线性结构——线性表及其表示
-"一,线性结构 1.顺序储存结构直接表示多项式. 1).使用数组来表示多项式.(用数组下标来表示指数,值来表示系数) 可以表示成: 2).使用结构数组来表示.(把系数和指数看成一个二元组 ...
队列：实用程序服务和数据结构
队列:实用程序服务和数据结构 Queues: utility services and data structures 队列实用程序服务 Nucleus RTOS有四个API调用,它们提供与队列相关的 ...
管道：实用程序服务和数据结构
管道:实用程序服务和数据结构 Pipes: utility services and data structures 管道公用设施 Nucleus RTOS有四个API调用,它们提供与管道相关的实用程 ...

List------数据结构

1.Collection与Collections的区别？

2.object的常见方法

其实本质上来说 ListIterator接口也实现了Iterator接口

现在我们来进行实现一个ArrayList:

练习题一：输入:str1=abcqweracb 输出:abcqwer

3)这是不能够使用HashSet的，因为要按照字母的顺序来进行输出

练习题二:一个学校中有若干学生(学生对象放在一个List中，每一个学生有一个姓名，班级，和考试成绩的属性，某次考试成绩结束之后，每一个学生都获得了一个考试成绩.遍历List集合,把每一个学生对象的属性都打印出来；

List<String> list1=new ArrayList<>();

ArrayList<String> list2=new ArrayList<>();

练习题三:删除第一个字符串中出现的第二个字符串中的字符；例如 String str1=" welcome to bit"; String str2="come" 输出的结果是wl t bit