Java--集合(LinkedList，泛型)

LinkedList

一、LinkedList类

[1]public void addFirst(E e)及addLast(E e)
[2]public E getFirst()及getLast()
[3]public E removeFirst()及public E removeLast()
[4]public E get(int index);
栈：先进后出，底端闭口



队列：先进先出，两端开口



import java.util.ArrayList;
import java.util.LinkedList;

@SuppressWarnings({ "rawtypes", "unchecked" })
public class LinkedListMethod {
public static void main(String[] args) {
/*
* 一、LinkedList类
[1]public void addFirst(E e)及addLast(E e)
[2]public E getFirst()及getLast()
[3]public E removeFirst()及public E removeLast()
[4]public E get(int index);
* */
initLinkedList();
simulateSatck();//使用LinkedList模拟栈操作
simulateQueue();//使用LinkedList模拟栈操作
}

//使用LinkedList模拟栈操作(先进后出)
private static void simulateSatck() {
System.out.println("===========模拟栈、队列============");
Stack s = new Stack();
s.in("a");
s.in("b");
s.in("c");
s.in("d");
s.forAll();
System.out.println();
while(!s.isEmpty()){
System.out.print(s.outStack() + " ");
}
System.out.println();
}

//使用LinkedList模拟栈操作(先进后出)
private static void simulateQueue() {
System.out.println("===========模拟队列============");
Stack s = new Stack();
s.in("a");
s.in("b");
s.in("c");
s.in("d");
s.forAll();
System.out.println();
while(!s.isEmpty()){
System.out.print(s.outQueue() + " ");
}
System.out.println();
}

private static void initLinkedList() {
LinkedList li = new LinkedList();
li.addFirst("a");
li.addFirst("b");
li.addFirst("c");
li.addLast("e");
System.out.println(li);
li.removeFirst();
li.removeLast();
System.out.println(li);
System.out.println(li.get(1));
}
}
LinkedList模拟栈和队列操作
import java.util.LinkedList;

public class Stack {
@SuppressWarnings("rawtypes")
private LinkedList list = new LinkedList();

@SuppressWarnings("unchecked")
public void in(Object obj){
list.add(obj);
}

//栈----先进后出
public Object outStack(){
return list.removeLast();
}

//队列----先进先出
public Object outQueue(){
return list.removeFirst();
}

public boolean isEmpty(){
return list.isEmpty();
}

public void forAll(){
for(int i = 0;i < list.size();i++){
System.out.print(list.get(i) + " ");
}
}
}
泛型

一、泛型概述和基本使用
1、泛型的由来:通过Object转型问题引入
 早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。
 也就存在这隐患，所以Java提供了泛型来解决这个安全问题。
2、泛型好处
提高安全性(将运行期的错误转换到编译期) 
 省去强转的麻烦
3、泛型基本使用
<>中放的必须是引用数据类型 
4、泛型使用注意事项
前后的泛型必须一致,或者后面的泛型可以省略不写(1.7的新特性菱形泛型)
二、泛型类：泛型定义在类上
定义格式
public class 类名<泛型类型1,…>
泛型类型必须是引用类型
三、泛型方法：把泛型定义在方法上
定义格式

public <泛型类型> 返回类型 方法名(泛型类型 变量名)
四、泛型接口：把泛型定义在接口上
定义格式

      public interface 接口名<泛型类型>
五、泛型通配符<?>：任意类型，如果没有明确，那么就是Object以及任意的Java类了
1、? extends E
向下限定，E及其子类
2、? super E
向上限定，E及其父类
六、增强for：简化数组和Collection集合的遍历
for(元素数据类型 变量 : 数组或者Collection集合) {
使用变量即可，该变量就是元素
}
七、静态导入概述
import static 包名….类名.方法名;
可以直接导入到方法的级别
注意事项：方法必须是静态的,如果有多个同名的静态方法，容易不知道使用谁?这个时候要使用，必须加前缀。
由此可见，意义不大，所以一般不用，但是要能看懂
八、可变参数：定义方法的时候不知道该定义多少个参数
格式
修饰符 返回值类型 方法名(数据类型…  变量名){}
注意事项：
这里的变量其实是一个数组
如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Iterator;

public class Generic {
public static void main(String[] args) {
/*
* 一、泛型概述和基本使用
1、泛型的由来:通过Object转型问题引入
早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。
也就存在这隐患，所以Java提供了泛型来解决这个安全问题。
2、泛型好处
提高安全性(将运行期的错误转换到编译期)
省去强转的麻烦
3、泛型基本使用
<>中放的必须是引用数据类型
4、泛型使用注意事项
前后的泛型必须一致,或者后面的泛型可以省略不写(1.7的新特性菱形泛型)
二、泛型类：泛型定义在类上
定义格式
public class 类名<泛型类型1,…>
泛型类型必须是引用类型
三、泛型方法：把泛型定义在方法上
定义格式
public <泛型类型> 返回类型 方法名(泛型类型 变量名)
四、泛型接口：把泛型定义在接口上
定义格式
public interface 接口名<泛型类型>
五、泛型通配符<?>：任意类型，如果没有明确，那么就是Object以及任意的Java类了
1、? extends E
向下限定，E及其子类
2、? super E
向上限定，E及其父类
六、增强for：简化数组和Collection集合的遍历
for(元素数据类型 变量 : 数组或者Collection集合) {
使用变量即可，该变量就是元素
}
七、静态导入概述
import static 包名….类名.方法名;
可以直接导入到方法的级别
注意事项
方法必须是静态的,如果有多个同名的静态方法，容易不知道使用谁?这个时候要使用，必须加前缀。
由此可见，意义不大，所以一般不用，但是要能看懂
八、可变参数：定义方法的时候不知道该定义多少个参数
格式
修饰符 返回值类型 方法名(数据类型… 变量名){}
注意事项：
这里的变量其实是一个数组
如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个
* */
initGeneric();
genericCome();

addFor();//for增强
removeFor();
arrayToList();//数组转集合
forFor();//嵌套循环
}

private static void forFor() {
ArrayList<ArrayList<Student>> list = new ArrayList<>();

ArrayList<Student> firstClass = new ArrayList<>();
firstClass.add(new Student("利达",17));
firstClass.add(new Student("利二",18));
firstClass.add(new Student("利三",19));

ArrayList<Student> secondClass = new ArrayList<>();
secondClass.add(new Student("益达",17));
secondClass.add(new Student("益二",18));
secondClass.add(new Student("益三",19));

list.add(firstClass);
list.add(secondClass);

for(ArrayList<Student> newClass :list){
for(Student s : newClass){
System.out.println(s);
}
}
}

/*
* 数组转换成集合
* 数组转换成集合不能增加或减少元素，但是可以使用集合的思想操作数组，即可以使用其它集合中的方法
* */
private static void arrayToList() {
System.out.println("===========数组转集合===========");
String[] sA = {"a","b","c","d"};
List<String> list = (List<String>) Arrays.asList(sA);
System.out.println(list);
}

private static void removeFor() {
System.out.println("===========for删除===========");
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("b");
list.add("c");
list.add("d");

// //1、for删除
// for (int i = 0; i < list.size(); i++) {
// if("b".equals(list.get(i))){
// list.remove(i--);
// }
// }

//2、迭代器删除
Iterator<String> it = list.iterator();
while(it.hasNext()){
if("b".equals(it.next())){
// list.remove(it.next());
/*java.util.ConcurrentModificationException并发修改异常
不能使用集合的方法删除，因为迭代过程中如果修改就出现并发修改异常
*/
it.remove();//使用迭代器本身的方法
}
}

// //3、增强for循环
// for (String string : list) {
// if("b".equals(string)){
// list.remove("b"); //增强for循环只能遍历不能删除
// }
// }
System.out.println(list);
}

//for增强
private static void addFor() {
int[] arr = {11,22,33,44,55};
for (int i : arr){
System.out.print(i + " ");
}
System.out.println();
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
for (String string : list) {
System.out.print(string + " ");
}
System.out.println();
}

private static void genericCome() {
Tool<GirlStudent> t = new Tool<>();
t.setObj(new GirlStudent("花季",16));

//java.lang.ClassCastException 类转换异常
// BoyStudent bs = (BoyStudent) t.getObj();
GirlStudent gs = t.getObj();

Tool<String> t1 = new Tool<>();
t1.show("abc");
}

private static void initGeneric() {
ArrayList<Student> arrList = new ArrayList<Student>();
arrList.add(new Student("王二",18));
arrList.add(new Student("张三",22));
arrList.add(new Student("李四",20));
arrList.add(new Student("赵六",16));

Iterator<Student> it = arrList.iterator();
while(it.hasNext()){
//next方法只能调用一次，如果调用多次就会将指针向后移动多次;因此创建一个对象指向next获取的对象
// System.out.println(it.next().getName() + "--" + it.next().getAge());
Student s = it.next();
System.out.println(s.getName() + "--" + s.getAge());
}
}
}

interface Inter<T>{
public void show(T t);
}

class Demo implements Inter<String>{ //推荐使用这种方法
public void show(String s){
System.out.println(s);
}
}

//class Demo<T> implements Inter<String>{ //实现接口时没必要对自己添加一个泛型
// public void show(String s){
// System.out.println(s);
// }
//}
泛型
//<一个大写字母>代表泛型
public class Tool<E> {
private E obj;

public E getObj() {
return obj;
}

public void setObj(E obj) {
this.obj = obj;
}

public<T> void show(T t){ //非静态方法泛型最好与类泛型一致
System.out.println(t); //如果不一致，最好在方法上声明该泛型;使用时传具体的值
}

public static<Q> void print(Q q){ //静态方法必须声明自己的泛型
System.out.println(q);
}
}