一、 List集合特有的功能概述
因為List集合繼承與Collection,所有有些方法類似,詳細介紹一些List特有的功能,List也是一個介面,故不能新建物件,所以我們呼叫子類ArrayList
- void add(int index,E element)
在指定位置添加元素
List list =new ArrayList();
list.add("a"); //從0開始
list.add("b");
list.add("c");
list.add("d");
list.add(1,"e");
list.add(10,"f");//java.lang.IndexOutOfBoundsException,
//當存盤時使用不存在的索引會存在陣列越界,當然index可以小于等于size,
System.out.println(list);
效果如下:

———————————————————————————————————————
- E remove(int index)
在指定位置洗掉元素
List list =new ArrayList();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
//記錄被洗掉的元素
Object obj =list.remove(1);
System.out.println(obj);
System.out.println(list);
效果如下:

tips:remove方法傳入的引數是索引,函式回傳的是Object物件,
弊端:當我們傳入的是數字的時候,他會把數字當成索引,
List list = new ArrayList();
list.add(111);
list.add(222);
list.add(333);
list.remove(111); //洗掉的時候不會自動裝箱,把111當作索引
System.out.println(list);
效果如下:

———————————————————————————————————————
- E get(int index)
傳入的引數是索引,我們可以通過索引獲取單個元素,所以我們可以通過for回圈來遍歷List集合,這是List集合特有的遍歷方式
List list =new ArrayList();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
//Object object1 =list.get(0);
//System.out.println(object1);
for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i));
}
效果如下:

———————————————————————————————————————
- E set(int index,E element)
修改值,把指定位置的元素修改掉
List list =new ArrayList();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.set(1, "z");
System.out.println(list);
效果如下:

二、 List集合存盤物件并遍歷
在不傳入泛型的情況下(需要進行向下轉型,后面會引入泛型):
List list =new ArrayList();
list.add(new Student("張三",12));//Object obj =new Student("張三",12);
list.add(new Student("李四",13));
list.add(new Student("王二",14));
list.add(new Student("趙六",15));
for (int i = 0; i < list.size(); i++) {
//單純的遍歷
System.out.println(list.get(i));
//通過索引獲取每一個元素
Student s = (Student) list.get(i);
System.out.println(s.getName()+" "+s.getAge());
}
效果如下:

三、 集合框架(并發修改例外產生的原因及解決方案)
需求:我有一個集合,請問,我想判斷里面有沒有"world"這個元素,如果有,我就添加一個"javaee"元素,請寫代碼實作,
List list =new ArrayList();
list.add("a");
list.add("b");
list.add("world");
list.add("c");
list.add("d");
list.add("e");
Iterator it =list.iterator();
while (it.hasNext()) {
//進行強轉的原因是因為list添加進去的元素被提升為Object型別
String str = (String) it.next();
if ("world".equals(str)) {
list.add("javaee");
}
System.out.println(list);
}
效果如下:

此為并發修改例外當放大檢測到物件的并發修改,但不允許這種修改時,拋出例外,也就是說,集合在添加的時候并沒有告訴迭代器,將要添加資料,而是迭代器自主突然想要添加資料,遍歷的同時也在增加元素,并發修改,進行了報錯例外,
———————————————————————————————————————
解決方案:
迭代器迭代元素,使用專門的迭代器添加元素(ListIterator())
List list =new ArrayList();
list.add("a");
list.add("b");
list.add("world");
list.add("c");
list.add("d");
list.add("e");
ListIterator lit =list.listIterator(); //List集合特有
while (lit.hasNext()) {
String str = (String)lit.next();
if ("world".equals(str)) {
lit.add("javaee");
}
}
System.out.println(list);
}
效果如下:

四、 ListIterator介紹(了解即可)
- boolean hasNext()是否有下一個
- boolean hasPrevious()是否有前一個
- Object next()回傳下一個元素
- Object previous();回傳上一個元素
List list = new ArrayList();
list.add("a");
//Object obj = new String();
list.add("b");
list.add("world");
list.add("c");
list.add("d");
list.add("e");
ListIterator lit = list.listIterator();
//獲取迭代器
while(lit.hasNext()) {
System.out.println(lit.next());
//獲取元素并將指標向后移動
}
System.out.println("-----------------");
while(lit.hasPrevious()) {
System.out.println(lit.previous());
//獲取元素并將指標向前移動
}
如果我們注釋hasNext()方法,那么hasPrevious(),什么也遍歷不出,因為我們只有先執行hasNext()方法之后,指標才會往后移動,隨后hasPrevious()才會調出結果,
五、Vector—— List下的Vector
Vector類特有功能
- public void addElement(E obj)
- public E elementAt(int index)
- public Enumeration elements() //列舉
Vector v = new Vector();
v.addElement("a");
v.addElement("b");
v.addElement("c");
v.addElement("d");
Enumeration en = v.elements();
//獲取列舉
while(en.hasMoreElements()) {
//判斷集合中是否有元素
System.out.println(en.nextElement());
//獲取集合中的元素
}
}

六、 ArrayList——去除ArrayList中重復字串元素方式
- 分析:
`* 1.創建新集合 - 2.根據傳入的集合(老集合獲取迭代器)
- 3.遍歷老集合
- 4.通過新集合判斷是否包含老集合的元素,如果包含就不添加,如果不包含就添加
public class Demo1_ArrayList {
public static void main(String[] args) {
// TODO Auto-generated method stub
ArrayList list =new ArrayList();
list.add("a");
list.add("a");
list.add("b");
list.add("b");
list.add("c");
list.add("c");
ArrayList newList=getSingle(list);
System.out.println(newList);
}
public static ArrayList getSingle(ArrayList list) {
ArrayList newList =new ArrayList(); //1.創建新集合
Iterator it =list.iterator(); //2.根據傳入的集合(老集合)獲取迭代器
while (it.hasNext()) { //3.遍歷老集合
Object obj =it.next(); //記錄住每一個元素
if (!newList.contains(obj)) {
newList.add(obj);
}
}
return newList;
}
}
效果如下:

七、ArrayList—— 去除ArrayList中重復自定義物件元素(重點)
案例:
第一步:新建Bean集合
public class Person {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
//注意該處重寫了equals方法
@Override
public boolean equals(Object obj) {
Person p =(Person)obj;
return this.name.equals(p.name) &&this.age == p.age;
}
}
public class Demo2_ArrayList {
public static void main(String[] args) {
// TODO Auto-generated method stub
ArrayList list =new ArrayList();
//創建集合物件
list.add(new Person("張三",12));
list.add(new Person("張三",12));
list.add(new Person("李四",13));
list.add(new Person("李四",13));
list.add(new Person("李四",13));
list.add(new Person("李四",13));
ArrayList newList =getSingle(list);
//呼叫方法去除重復
System.out.println(newList);
}
public static ArrayList getSingle(ArrayList list) {
ArrayList newList =new ArrayList();
//創建新集合
Iterator it =list.iterator();
//根據傳入的集合(老集合)獲取迭代器
while (it.hasNext()) {
//遍歷老集合
Object object =it.next();
//記錄住每一個元素
if (!newList.contains(object)) {
//如果新集合中不包含老集合中的元素
newList.add(object) ; //將該元素添加
}
}
return newList;
}
}
效果如下:

tips:注意該處
重寫了父類的equals,因為父類中的方法的contains方法,里面進行判斷用的是equals()方法,我們需要進行修改,當然如果我們呼叫remove()方法,依舊依賴于equals()方法,進行包含判斷,
八、 LinkedList——LinkedList的特有功能
- public void addFirst(E e)及addLast(E e)
addFirst()是在陣列的頭部添加,addLast()是在陣列的尾部添加,
LinkedList list =new LinkedList();
list.addFirst("a");
list.addFirst("b");
list.addFirst("c");
list.addFirst("d");
list.addLast("e");
System.out.println(list);
效果如下:

———————————————————————————————————————
- public E getFirst()及getLast()
getFirst()獲得第一個元素,getLast()獲得最后一個元素
LinkedList list =new LinkedList();
list.addFirst("a");
list.addFirst("b");
list.addFirst("c");
list.addFirst("d");
list.addLast("e");
System.out.println(list);
System.out.print("第一個是");
System.out.println(list.getFirst());
System.out.print("最后一個是");
System.out.println(list.getLast());
效果如下:

———————————————————————————————————————
- public E removeFirst()及public E removeLast()
removeFirst()洗掉第一個元素,removeLast洗掉最后一個元素
LinkedList list =new LinkedList();
list.addFirst("a");
list.addFirst("b");
list.addFirst("c");
list.addFirst("d");
list.addLast("e");
System.out.print("洗掉第一個元素");
System.out.println(list.removeFirst());
System.out.print("洗掉第一個元素");
System.out.println(list.removeLast());
System.out.println(list);
效果如下:

———————————————————————————————————————
- public E get(int index);
引數傳入的是索引,可以通過索引找出數
LinkedList list =new LinkedList();
list.addFirst("a");
list.addFirst("b");
list.addFirst("c");
list.addFirst("d");
list.addLast("e");
System.out.println(list.get(1));
效果如下:

———————————————————————————————————————
九、 用LinkedList模擬堆疊資料結構的集合并測驗(重點)
分析我們使用LinkedList中的addLast()方法模擬進堆疊,removeLast()模擬出堆疊,因為我們是模擬堆疊,所以最好使用一個類,把LinkedList封裝到類中,類的名字為堆疊,
public class Stack {
private LinkedList list =new LinkedList();
//模擬進堆疊方法
public void in(Object obj) {
list.addLast(obj);
}
//模擬出堆疊
public Object out() {
return list.removeLast();
}
//模擬堆疊結構是否為空
public boolean isEmpty() {
return list.isEmpty();
}
}
呼叫除錯:
Stack stack = new Stack();
stack.in("a");
stack.in("b");
stack.in("c");
stack.in("d");
while (!stack.isEmpty()) {
System.out.println(stack.out());
}
在此基礎上我們會可以模擬佇列,佇列是先進先出,只要修改removeLast()改為removeFirst()
十、 List三個子類的特點
ArrayList:
底層資料結構是陣列,查詢快,增刪慢,
執行緒不安全,效率高,
Vector:
底層資料結構是陣列,查詢快,增刪慢,
執行緒安全,效率低,
Vector相對ArrayList查詢慢(執行緒安全的)
Vector相對LinkedList增刪慢(陣列結構)
LinkedList:
底層資料結構是鏈表,查詢慢,增刪快,
執行緒不安全,效率高,
Vector和ArrayList的區別
Vector是執行緒安全的,效率低
ArrayList是執行緒不安全的,效率高
共同點:都是陣列實作的
ArrayList和LinkedList的區別
ArrayList底層是陣列結果,查詢和修改快
LinkedList底層是鏈表結構的,增和刪比較快,查詢和修改比較慢
共同點:都是執行緒不安全的
List有三個兒子,我們到底使用誰呢?
查詢多用ArrayList
增刪多用LinkedList
如果都多ArrayList
Vector面試的時候用,其已經被ArrayList代替,執行緒安全一般用vector但是后面會使用工具類,把執行緒不安全的陣列改成執行緒安全的,所以Vector用的比較少,
十一、 增強for(For-Each)的概述和使用
增強for概述
簡化陣列和Collection集合的遍歷
格式:
for(元素資料型別 變數 : 陣列或者Collection集合) {
使用變數即可,該變數就是元素
}
當我們遍歷陣列和集合
int arr[] = {11,22,33,44,55,66};
List<String> list =new ArrayList<String>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
for (String string : list) {
System.out.print(string);
}
System.out.println();
for (int i : arr) {
System.out.print(i);
}
當我們遍歷物件的時候
List<Person> list =new ArrayList<Person>();
list.add(new Person("張三 ", 12));
list.add(new Person("李四 ", 13));
list.add(new Person("王五 ", 14));
for (Person person : list) {
System.out.println(person);
}
增強for回圈底層依賴的是迭代器(Iterator)
十二、 三種迭代的能否洗掉
普通for回圈
List<String> list =new ArrayList<String>();
list.add("a");
list.add("b");
list.add("b");
list.add("c");
list.add("b");
list.add("d");
//1.普通for回圈洗掉
for (int i = 0; i < list.size(); i++) {
if ("b".equals(list.get(i))) {
list.remove(i--);
//通過索引洗掉元素,應該改為remove(i--)使元素往后移動一位
}
}
System.out.println(list);
效果如下:

———————————————————————————————————————
迭代器洗掉
//方法一:
Iterator<String> iterator =list.iterator();
while (iterator.hasNext()) {
if ("b".equals(iterator.next())) {
//list.remove("b");
//不能用集合的洗掉方法,因為迭代程序中如果集合修改會出現并發修改例外
iterator.remove();
}
}
//方法二:
for (Iterator<String> iterator2 =list.iterator();iterator2.hasNext(); ) {
if ("b".equals(iterator.next())) {
//list.remove("b");
//不能用集合的洗掉方法,因為迭代程序中如果集合修改會出現并發修改例外
iterator.remove();
}
}
System.out.println(list);
tips:以上為兩種不同的寫法,并非不同的方法,
———————————————————————————————————————
增強for回圈
該方法不能洗掉 只能遍歷;
十三、 陣列轉集合以及集合轉陣列
陣列轉集合方法:Arrays工具類的asList()方法的使用
該方法用于將陣列轉換為集合,但是不能進行集合的增加和洗掉元素操作,但是可以運行一些迭代器進行遍歷挑選,
String [] arr= {"a","b","c"};
List<String> list = Arrays.asList(arr);
list.add("d");
//該處不能添加
System.out.println(list);
//報錯
———————————————————————————————————————
當我們存盤一些int型別的基本型別資料的時候,將整個陣列當成一個物件存盤在集合中
注意該泛型應該是一個int型的陣列
int [] arr= {11,22,33,44,55};
List<int []> list =Arrays.asList(arr);
//
System.out.println(list);
效果如下:

處理方法:
Integer[ ] arr= {11,22,33,44,55};
//陣列必須是參考基本型別
List<Integer > list =Arrays.asList(arr);
System.out.println(list);
集合轉陣列方法:
Collection中toArray(T[] a)泛型版的集合轉陣列
ArrayList<String> list =new ArrayList<String>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
String[] arr=list.toArray(new String[0]);
//后面陣列的0,當集合轉換為陣列時
//陣列的長度如果是小于等于集合的size()時,轉換后的陣列長度等于集合size()
//如果陣列長度大于集合長度,那么會輸出null
for (String string : arr) {
System.out.println(string);
}
效果如下:

———————————————————————————————————————
十四、 集合嵌套之ArrayList嵌套ArrayList
學科為大集合,學科又分為若干個班級
ArrayList<ArrayList<Person>> list =new ArrayList<ArrayList<Person>>();
ArrayList<Person> list1 = new ArrayList<Person>();
list1.add(new Person("小明",12));
list1.add(new Person("小紅",13));
ArrayList<Person> list2 = new ArrayList<Person>();
list2.add(new Person("張三",14));
list2.add(new Person("李四",15));
list.add(list1);
list.add(list2);
//遍歷學科集合
for (ArrayList<Person> A : list) {
for (Person person : A) {
System.out.println(person);
}
}
效果如下:

轉載請註明出處,本文鏈接:https://www.uj5u.com/qita/94598.html
標籤:其他
