Day16_集合第二天

1、LinkedList类(掌握)

1、特点

底层数据结构是链表，查询慢，增删快

线程不安全，效率高。

LinkedList 成员方法
void addFirst(Object o)	添加
void addLast(Object o)
Objcet getFirst()	获取
Object getLast()
Object removeFirst()	删除
Object removeLast()

  

2、栈和队列数据结构(掌握)

1、栈

     特点：先进后出

2、队列

     特点：先进先出

3、数组

     特点：查询快，增删慢

4、链表

     特点：查询慢，增删快

数据结构面试题：模仿Stack

3、泛型（能看懂什么是泛型的声明，什么是泛型的使用即可）

1、概述

     泛型是一种把明确类型的工作放在了创建对象或者调用方法时候才去明确的特殊的类型

     泛型就相当于一个预定义类型

2、好处(掌握)

     B、把系统运行期间的异常提前到了编译期间，提高了安全性

     C、优化了程序设计，不需要做强制转换了

3、不足(掌握)

     泛型传入的只能是引用类型

4、泛型通配符

     <?>  任意类型

    <? extends E> E包括E的子类，也叫向下限定

    <? super E> E包括E的父类，也叫向上限定

3、泛型的定义

     A、在类上定义

          说明：

               T,S是名字，可以随意起，该处定义的泛型可以在本类的任意地方使用

               父类上定义的泛型不能被子类继承

/**在类上定义一个泛型*/
class Person1<T> {
}

/**在类上定义两个泛型*/
class Person2<T,S>{
}

/**在类上定义两个泛型，且第二个类型S必须F或者F的子类*/
class Person3<F, S extends F>{
}

      B、在方法上定义

          因为返回值类型也可能会用到泛型类型，所以泛型的声明要在返回值之前

          说明：

               T,S是名字，可以随意起，该处定义的泛型可以在该方法的任意地方使用

/**在方法上声明一个泛型*/
public <T> void show(T t){
}
	
/**在方法上声明两个泛型*/
public <T,S> void show(T t, S s){
}
	
/**在方法上声明两个泛型,切第二个类型S必须是F或者F的子类*/
public <F,S extends F> void show(){
}

     C、在接口上定义泛型

         和在类上定义一样

3、泛型的使用

     可以在继承关系，实现关系，创建对象时使用

4、易错题解析

interface English<T> {
	void speakEnglish();
}

/**
 * 
 * 问题：可以调用以下String中的substring方法吗
 * 第一个<String>是声明一个泛型，名字叫String
 * 第二个<String>是使用刚才声明好的泛型
 * 所以这两个String与java.lang包下的String没有任何关系
 */
class Person<String> implements English<String>{
	@Override
	public void speakEnglish() {
	}
}

4、静态导入(了解)

1、概述

    静态导入是导入类中静态方法

2、格式

    import static 包名….类名.方法名;

3、注意事项

    方法必须是静态的,如果有多个同名的静态方法，容易不知道使用谁?这个时候要使用，必须加前缀。由此可见，意义不大，所以一般不用，但是要能看懂。

    静态导入开发不用,但是需要能看懂

4、案例

import static java.util.Arrays.sort;			//静态导入
public class Demo2_StaticImport {
	public static void main(String[] args) {
		int[] arr = {55,22,33,44,11};
		sort(arr);	
	}
}

5、增强for循环(掌握)

1、格式

     for(数组 或 Collection子类 的元素类型 变量名 ：数组 或 Collection子类)

     {

          //使用变量

     }

2、好处

     方便数组和集合的遍历

3、注意事项

     增强for是用来代替Iterator的

     不要再遍历的时候用集合对集合本身进行修改

4、集合遍历的四种方式

     1、迭代

     2、将集合转换为数组(忘记吧)

     3、获取集合的长度，通过get()+for遍历

     4、使用for高级循环(常用)

               for(Object obj : list){

                    System.out.println(obj);

               }

6、可变参数(掌握)

1、概述

    定义方法的时候不知道该定义多少个参数

2、格式

    修饰符 返回值类型 方法名(数据类型…  变量名){}

3、注意事项

    这里的变量其实是一个数组

    如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个

package com.heima.jdk5;

public class Demo3_ChangeableArgs {
	public static void main(String[] args) {
		print(11,22,33,44,55);
	}
	public static void print(int ... arr) {			//可变参数其实是一个数组
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}
}

7、案例(掌握)

1、ArrayList去除集合中字符串的重复值(字符串的内容相同)，创建新集合方式

2、ArrayList去除集合中自定义对象元素的重复值(对象的成员变量值相同)，因为contains方法比较对象的equals方法，所以自定义对象要重写equals方法

3、数据结构面试题：用LinkedList模拟栈结构(栈结构：先进后出)

4、ArrayList存储自定义对象和String类型数据，通过泛型实现

5、Arrays.asList练习

6、ArrayList   嵌套 ArrayList 练习

8、案例代码(掌握)

1、ArrayList去除集合中字符串的重复值(字符串的内容相同)，创建新集合方式

package com.heima.list;

import java.util.ArrayList;
import java.util.Iterator;

@SuppressWarnings({ "rawtypes", "unchecked" })
public class Demo1_ArrayList {

	/**
	 * * A:案例演示
		* 需求：ArrayList去除集合中字符串的重复值(字符串的内容相同)
		* 思路：创建新集合方式
	 */
	public static void main(String[] args) {
		ArrayList list = new ArrayList();
		list.add("a");
		list.add("a");
		list.add("b");
		list.add("b");
		list.add("c");
		list.add("c");
		list.add("c");
		list.add("c");
		
		ArrayList newList = getSingle(list);
		System.out.println(newList);
	}

	/*
	 * 创建新集合将重复元素去掉
	 * 1,明确返回值类型,返回ArrayList
	 * 2,明确参数列表ArrayList
	 * 
	 * 分析:
	 * 1,创建新集合
	 * 2,根据传入的集合(老集合)获取迭代器
	 * 3,遍历老集合
	 * 4,通过新集合判断是否包含老集合中的元素,如果包含就不添加,如果不包含就添加
	 */
	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;
	}
}

2、ArrayList去除集合中自定义对象元素的重复值(对象的成员变量值相同)，因为contains方法比较对象的equals方法，所以自定义对象要重写equals方法

package com.heima.list;

import java.util.ArrayList;
import java.util.Iterator;

import com.heima.bean.Person;

@SuppressWarnings({ "rawtypes", "unchecked" })
public class Demo2_ArrayList {

	/**
	 * * A:案例演示
			* 需求：ArrayList去除集合中自定义对象元素的重复值(对象的成员变量值相同)
		* B:注意事项
			* 重写equals()方法的
		contains方法判断是否包含,底层依赖的是equals方法
		remove方法判断是否删除,底层依赖的是equals方法
	 */
	public static void main(String[] args) {
		ArrayList list = new ArrayList();				//创建集合对象
		list.add(new Person("张三", 23));
		list.add(new Person("张三", 23));
		list.add(new Person("李四", 24));
		list.add(new Person("李四", 24));
		list.add(new Person("李四", 24));
		list.add(new Person("李四", 24));
		
		//ArrayList newList = getSingle(list);			//调用方法去除重复
		//System.out.println(newList);
		list.remove(new Person("张三", 23));
		System.out.println(list);
	}

	/*
	 * 创建新集合将重复元素去掉
	 * 1,明确返回值类型,返回ArrayList
	 * 2,明确参数列表ArrayList
	 * 
	 * 分析:
	 * 1,创建新集合
	 * 2,根据传入的集合(老集合)获取迭代器
	 * 3,遍历老集合
	 * 4,通过新集合判断是否包含老集合中的元素,如果包含就不添加,如果不包含就添加
	 */
	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;
	}
}

3、数据结构面试题：用LinkedList模拟栈结构(栈结构：先进后出)

package com.heima.list;

import java.util.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();
	}
}

4、ArrayList存储自定义对象和String类型数据，通过泛型实现

package com.heima.generic;

import java.util.ArrayList;
import java.util.Iterator;

import com.heima.bean.Person;

public class Demo2_Generic {

	/**
	 * * A:案例演示
	 * ArrayList存储字符串并遍历泛型版
	 */
	public static void main(String[] args) {
		//demo1();
		ArrayList<Person> list = new ArrayList<>();
		list.add(new Person("张三", 23));
		list.add(new Person("李四", 24));
		list.add(new Person("王五", 25));
		list.add(new Person("赵六", 26));
		
		Iterator<Person> it = list.iterator();
		while(it.hasNext()) {
			Person p = it.next();							//将集合中的每一个元素用Person记录
			System.out.println(p.getName() + "..." + p.getAge());
		}
	}

	public static void demo1() {
		ArrayList<String> list = new ArrayList<>();			//创建集合对象
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		
		Iterator<String> it = list.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
	}

}

5、Arrays.asList练习

package com.heima.jdk5;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Demo4_AsList {

	/**
	 * 数组转换成集合
	 * 数组转换成集合虽然不能增加或减少元素,但是可以用集合的思想操作数组,也就是说可以使用其他集合中的方法
	 */
	public static void main(String[] args) {
		//demo1();
		//demo2();
		//集合转数组,加泛型的
		ArrayList<String> list = new ArrayList<>();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		
		String[] arr = list.toArray(new String[10]);		//当集合转换数组时,数组长度如果是小于等于集合的size时,转换后的数组长度等于集合的size
															//如果数组的长度大于了size,分配的数组长度就和你指定的长度一样
		for (String string : arr) {
			System.out.println(string);
		}
	}

	public static void demo2() {
		//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);
	}

	public static void demo1() {
		String[] arr = {"a","b","c"};
		List<String> list = Arrays.asList(arr);				//将数组转换成集合
		//list.add("d");									//不能添加
		System.out.println(list);
	}

}

6、ArrayList   嵌套 ArrayList 练习

package com.heima.list;

import java.util.ArrayList;

import com.heima.bean.Person;

public class Demo5_ArrayListArrayList {

	/**
	 * * A:案例演示
	 * 集合嵌套之ArrayList嵌套ArrayList
	 * 案例:
	 * 我们学科,学科又分为若个班级
	 * 整个学科一个大集合
	 * 若干个班级分为每一个小集合
	 */
	public static void main(String[] args) {
		ArrayList<ArrayList<Person>> list = new ArrayList<>();
		
		ArrayList<Person> first = new ArrayList<>();				//创建第一个班级
		first.add(new Person("杨幂", 30));
		first.add(new Person("李冰冰", 33));
		first.add(new Person("范冰冰", 20));
		
		ArrayList<Person> second = new ArrayList<>();
		second.add(new Person("黄晓明", 31));
		second.add(new Person("赵薇", 33));
		second.add(new Person("陈坤", 32));
		
		//将班级添加到学科集合中
		list.add(first);
		list.add(second);
		
		//遍历学科集合
		for(ArrayList<Person> a : list) {
			for(Person p : a) {
				System.out.println(p);
			}
		}
	}

}

7、在遍历的时候删除集合中的元素

/**
 * 在遍历的时候删除集合中的元素
 */
public class Test3 {
	public static void main(String[] args) {
		ArrayList<String> al = new ArrayList<String>();
		al.add("a");
		al.add("a");
		al.add("a");
		al.add("b");
		
		//删除所有的a
		for(int i=0; i<al.size(); i++){
			String string = al.get(i);
			if(string.equals("a")){
				al.remove(i--);
			}
		}
	}
}

9、今天必须掌握的内容，面试题，笔试题

1、ArrayList去除集合中字符串的重复值(字符串的内容相同)，创建新集合方式

2、ArrayList去除集合中自定义对象元素的重复值(对象的成员变量值相同)，因为contains方法比较对象的equals方法，所以自定义对象要重写equals方法

3、用LinkedList模拟栈结构

4、练习泛型：ArrayList<Student>集合的遍历

5、说说栈和队列的数据结构

6、代码题：练习泛型的使用。定义一个方法swap()传入集合和两个角标使集合中元素交换位置

package com.heima.test;
 
import java.util.ArrayList;
import java.util.List;
 
import com.heima.bean.Person;
 
/*
 * 1,定义一个方法swap()传入集合和两个角标使集合中元素交换位置
	a,定义一个临时变量, 记住其中一个元素
	b,用第一个位置存放第二个位置上的元素
	c, 用第二个位置存放临时变量记住的元素
 */
public class Test1 {
	public static void main(String[] args) {
		//测试集合中存入字符串
		ArrayList<String> al = new ArrayList<>();
		al.add("a");
		al.add("b");
		al.add("c");
		al.add("d");
		System.out.println(al);
		swap(al,0,3);
		System.out.println(al);
		//测试集合中存入自定义对象
		ArrayList<Person> al2 = new ArrayList<>();
		al2.add(new Person("zs", 20));
		al2.add(new Person("ls", 30));
		al2.add(new Person("ww", 10));
		al2.add(new Person("zl", 40));
		al2.add(new Person("kw", 22));
		System.out.println("------------------");
		System.out.println(al2);
		swap(al2,0,4);
		System.out.println(al2);
	}
	//定义一个带泛型的方法
	public static <T> void swap(List<T> list,int index1,int index2) {
		//1.获取list集合中索引为index1的值
		T t = list.get(index1);
		//2.将集合中索引index1位置设置为索引index2的值
		list.set(index1, list.get(index2));
		//3.将集合index2位置设置为t
		list.set(index2, t);
	}
}

7、代码题：练习集合中元素的删除和正则。编写一个方法删除集合List<String>中所有包含数字的元素

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
 * 编写一个方法删除集合List<String>中所有包含数字的元素
 * 
 * @author haoyongliang
 * 
 */
public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("abce0fgh");
        list.add("ab2e0fgh");
        list.add("a");
        list.add("ab3e0fgh");
        list.add("ab5e0fgh");
        list.add("ab6e0fgh");
        list.add("ab5e0f8gh");
        list.add("ab5e0f8gh");
        delete(list);
        System.out.println(list);
    }
    private static void delete(List<String> list) {
        for (int i = 0; i < list.size(); i++) {
            String string = list.get(i);
            if (string.matches(".*\\d+.*")) {
                list.remove(i);
                i--;
            }
        }
    }
}

8、向ArrayList中存入一堆学生对象，并且找出年龄最大的那个人

9、集合ArrayList<String>存储了一堆元素，将集合中的所有出现"aa"的元素全部替换成"bb"

10、把集合中的元素反转

来自为知笔记(Wiz)