List
(1)List集合的元素有序(存储和取出顺序一致),元素可重复
(2)List的特有功能：
添加功能
void add(int index,Object obj):在指定的位置添加元素
删除功能
Object remove(int index):通过指定的索引删除元素，并把删除的元素返回
获取功能
get(int index) 返回列表中指定位置的元素。
替换功能
Object set(int index,Object obj）
案例：
1.List存储字符串并遍历(迭代器,普通for)
2.List存储自定义对象并遍历(迭代器,普通for）
List的倒序与洗牌
List中元素顺序可以被洗牌Collections.shuffle(list)
List中元素顺序可以被倒序Collections.reverse(list)
Collections.sort(list)对List元素排序（字母数字分别进行测试）
/*
(1)List集合的元素有序(存储和取出顺序一致),元素可重复
(2)List的特有功能：
A:添加功能
void add(int index,Object obj):在指定的位置添加元素
B:删除功能
Object remove(int index):通过指定的索引删除元素，并把删除的元素返回
C:获取功能
get(int index) 返回列表中指定位置的元素。
D:替换功能
Object set(int index,Object obj)*/
import java.util.*;
public class ListDemo {
public static void main(String[] args) {
//创建List集合,List集合特点：元素的存入和取出的顺序一致
List<String> list = new ArrayList<String>();
list.add("hello");
list.add("world");
list.add("java");
//void add(int index,Object obj):在指定的位置添加元素
//list.add(1, "php");
//Object remove(int index):通过指定的索引删除元素，并把删除的元素返回
//Object remove = list.remove(1);
//System.out.println(remove);
//get(int index) 返回列表中指定位置的元素。
// Object object = list.get(0);
// System.out.println(object);
//list集合的特有的便利方式，通过get（int index）,和size()方法，可以通过普通for循环去遍历list集合
/*for(int i=0;i<list.size();i++){
Object object = list.get(i);
String str = (String)object;
System.out.println(str);
}*/
//Object set(int index,Object obj),将指定的索引处的元素替换成指定元素，并且将原来的老的元素返回
String set = list.set(2, "c++");
System.out.println(set);
System.out.println("---------------");
//遍历集合
Iterator<String> it = list.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
}
注意：1.集合操作的时候，导入包基本上都是在java.util下
2.类，接口等名称是首字母大写， 变量或者方法名首字母小写
3.创建list集合：List list = new ArrayList();
案例练习：
- 需求：用List集合存储3个汽车对象，然后遍历。
- 汽车：Car
- 成员变量：String brand,int price,String color
- 构造方法：无参，带参
- 成员方法：getXxx()/setXxx()
public class Car {
private String brand;
private int price;
private String color;
public Car(String brand, int price, String color) {
super();
this.brand = brand;
this.price = price;
this.color = color;
}
public Car() {
super();// TODO Auto-generated constructor stub
}
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
}
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class CarDemo {
public static void main(String[] args) {
//创建汽车对象
Car c1 = new Car("兰博", 300000, "黑色");
Car c2 = new Car("老司机", 600000, "黑色");
Car c3 = new Car("东风常拖", 1000000, "黑色");
//创建集合
List list = new ArrayList();
//给集合中添加元素
list.add(c1);
list.add(c2);
list.add(c3);
//迭代器遍历
Iterator it = list.iterator();
while (it.hasNext()) {
Object obj = it.next();
Car c = (Car)obj;
System.out.println(c.getBrand()+" "+c.getColor()+" "+c.getPrice());
}
System.out.println("----------------");
//普通for循环
for (int i = 0; i < list.size(); i++) {
Car car = (Car)list.get(i);
System.out.println(car.getBrand()+" "+car.getColor()+" "+car.getPrice());
}
System.out.println("----------------");
//增强for循环
for(Object obj:list){
Car car2 = (Car)obj;
System.out.println(car2.getBrand()+" "+car2.getColor()+" "+car2.getPrice());
}
}
}
ArrayList
案例1：存储字符串并遍历
案例2：存储自定义对象并遍历
LinkedList
案例1：存储字符串并遍历
案例2：存储自定义对象并遍历
LinkedList特有功能:
public void addFirst(E e)
public void addLast(E e)
public E getFirst()
public E getLast()
public E removeFirst()
public E removeLast()
ArrayList与LinkedList的相同点与不同点
相同点：有顺序的，元素可以重复
(1)ArrayList特点:
底层数据结构是数组,查询快,增删慢
线程不安全,效率高
(2)LinkedList特点:
底层数据结构是链表,查询慢,增删快
线程不安全,效率高
List的遍历（必须掌握）
1.for（普通for）
2.Iterator(迭代器)
3.foreach（增强for）
import java.util.LinkedList;
import java.util.List;
public class LinkedListDemo {
public static void main(String[] args) {
//创建一个LinkedList的集合
LinkedList list = new LinkedList();
list.add("hello");
list.add("world");
list.add("java");
// * public void addFirst(E e)
// * public void addLast(E e)
//需求：在hello前面加上一个元素“c++”
list.addFirst("c++");
list.addLast("js");
// * public E getFirst()
// * public E getLast()
// Object first = list.getFirst();
// Object last = list.getLast();
// System.out.println(first);
// System.out.println(last);
// * public E removeFirst()
// * public E removeLast()
Object removeFirst = list.removeFirst();
Object removeLast = list.removeLast();
System.out.println(removeFirst);
System.out.println(removeLast);
System.out.println("---------------");
//遍历集合
for(Object obj:list){
System.out.println(obj);
}
}
}
泛型入门
引入：是一种把明确数据类型的工作推迟到创建对象或者调用方法的时候才去明确类型的特殊类型
案例：创建集合存储字符串，存储integer类型数据，遍历的时候强制转换
与String数组进行对比，引入泛型
泛型(掌握)：如果不加泛型，我们只有在程序运行的时候发现他的错误，这样很不安全
是一种把明确数据类型的工作推迟到创建对象或者调用方法的时候才去明确类型的特殊类型
1.格式：
<数据类型>
默认情况下，是Object类型。
这里数据类型只能是引用类型。如果你看到写基本类型也行，其实这里使用了自动装箱。
2.好处：
A:把运行时期问题提前到了编译时期
B:避免了强制类型转换
C:优化程序设计，解决了黄色警告线问题
3.使用场景
一般来说就是在集合中用的多。
看API,如果类或者接口或者方法出现了<>说明这里就有泛型拓展
4.泛型的概述
A:泛型类（把泛型定义在类上）
B:泛型方法（把泛型定义在方法上）
C:泛型接口（泛型定义在接口上）
5.泛型通配符
在java中，数组是可以协变的，比如dog extends Animal，那么Animal[] 与dog[]是兼容的。而集合是不能协变的，也就是说List不是List的父类，这时候就可以用到通配符了。
类别：主要有以下三类:
- 无边界的通配符(Unbounded Wildcards), 就是<?>, 比如List<?>.
无边界的通配符的主要作用就是让泛型能够接受未知类型的数据. - 固定上边界的通配符(Upper Bounded Wildcards):
使用固定上边界的通配符的泛型, 就能够接受指定类及其子类类型的数据. 要声明使用该类通配符, 采用<? extends E>的形式, 这里的E就是该泛型的上边界. 注意: 这里虽然用的是extends关键字, 却不仅限于继承了父类E的子类, 也可以代指显现了接口E的类. - 固定下边界的通配符(Lower Bounded Wildcards):
使用固定下边界的通配符的泛型, 就能够接受指定类及其父类类型的数据. 要声明使用该类通配符, 采用<? super E>的形式, 这里的E就是该泛型的下边界.
注意: 你可以为一个泛型指定上边界或下边界, 但是不能同时指定上下边界.
public class GenericDemo<E> { //泛型存在于方法中
public void show(E e){
System.out.println(e);
}
//创建一个方法，将泛型加载方法上
public<BMW> void method(BMW bmw){
System.out.println(bmw);
}
}
public class Test {
public static void main(String[] args) {
GenericDemo<String> gd = new GenericDemo<String>();
gd.show("hello");
gd.method("hello");
gd.method(100);
gd.method('a');
}
}
public interface Inter<E> { //泛型存在于接口中，在接口的实现类实现它时 ，它就已经明确
}
public class InterImpl<E> implements Inter<E> {
}
