16-java学习-ArrayList、Vector、LinkedList、泛型(Generic)、可变参数、增强for循环-案例代码
1.ArrayList存储字符串并遍历泛型版
public class MyTest {
public static void main(String[] args) {
//泛型机制:就是把类型明确工作,推迟到创建对象,或调用方法是,才去明确的一种机制。
//泛型的好处:1.将问题提前到了编译期,2.避免了向下转型。
//泛型需要注意的是,泛型只在编译期有效,运行期就擦除了
//泛型可以定义在类,接口,方法上 语法<类型>
ArrayList<Integer> list = new ArrayList();
list.add(200);
list.add(200);
list.add(200);
list.add(200);
ArrayList list2 = new ArrayList();
list2.add("abc");
Object o = list2.get(0);
String str= (String) o;
System.out.println(str.length());
}
}
2. ArrayList存储自定义对象并遍历泛型版
public class MyTest2 {
public static void main(String[] args) {
//JDK1.5 之后引入泛型的
ArrayList<String> list = new ArrayList<String>();
list.add("aaaa");
list.add("aaaa");
list.add("aaaa");
list.add("aaaa");
list.add("aaaa");
//String s = list.get(0);
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()){
String next = iterator.next();
System.out.println(next);
}
System.out.println("=======================");
ArrayList<Object> list2 = new ArrayList<>();
}
}
3.
public class LinkedListDemo {
public static void main(String[] args) {
/* void addFirst (E e)
在此列表的开始处插入指定的元素。
void addLast (E e)
将指定的元素列表的结束。
E getFirst ()
返回此列表中的第一个元素。
E getLast ()
返回此列表中的最后一个元素。
E peek ()
检索,但不删除,此列表的头(第一个元素)。
E poll ()
检索并删除此列表的头(第一个元素)。
E pop ()
从这个列表所表示的堆栈中弹出一个元素。
E removeFirst ()
移除并返回此列表中的第一个元素。
E removeLast ()
移除并返回此列表中的最后一个元素。
*/
LinkedList linkedList = new LinkedList();
linkedList.addFirst(100);
linkedList.addFirst(200);
linkedList.addFirst(300);
Object pop = linkedList.pop();
System.out.println(pop);
Object pop2 = linkedList.pop();
System.out.println(pop2);
System.out.println(linkedList);
}
}
4.void forEach (Consumer < ? super E > action)
执行特定动作的每一个元素的 Iterable直到所有元素都被处理或操作抛出异常。
public class MyTest {
public static void main(String[] args) {
//List 集合元素有序,且允许重复元素
// ArrayList 底层数据结构是数组,查询快,增删慢 线程不安全效率高
// LinkedList 底层数据结构是链表,查询慢,增删快 线程不安全效率高
//Vector 底层数据结构是数组,查询快,增删慢 线程安全 效率低
ArrayList list = new ArrayList();
list.add("aaa");
list.add("aaa");
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("dddd");
list.add("eee");
list.add("fff");
//Consumer 接口
//当你以后看到一个方法的形参,要一个接口类型,你就传一个该接口的子类对象
//方式1,你定义一个类,实现这个接口
//方式2:匿名内部类
list.forEach(new Consumer() {
@Override
public void accept(Object o) {
System.out.println(o);
}
});
}
}
class MyConsumer implements Consumer<String>{
@Override
public void accept(String s) {
//s 就是你集合中的元素
System.out.println(s);
}
}
5.Vector
/* void addElement (E obj)
添加指定的组件到这个向量的结束,增加其大小由一个。
E elementAt ( int index)
返回指定索引处的组件。
E firstElement ()
返回第一个组件(在指数 0 项目)这个载体。
E lastElement ()
返回向量的最后一个组件。
void removeAllElements ()
从该向量中移除所有组件,并将其大小设置为零。
boolean removeElement (Object obj)
从该向量中移除第一个(最低索引)发生的参数。
void removeElementAt ( int index)
在指定的索引中删除组件。
void setElementAt (E obj,int index)
设置组件在指定的 index这个向量是指定的对象。*/
public class VectorDemo {
public static void main(String[] args) {
Vector vector = new Vector();
vector.addElement(100);
vector.addElement(200);
vector.addElement(300);
vector.addElement(400);
//Vector 集合有一个自己的迭代器
Enumeration elements = vector.elements();
while (elements.hasMoreElements()){
Object o = elements.nextElement();
System.out.println(o);
}
System.out.println("============================");
Object o = vector.elementAt(0);
Object o1 = vector.firstElement();
Object o2 = vector.lastElement();
vector.removeElement(100);
vector.removeAllElements();
}
}
public class MyList {
private LinkedList linkedList=null;
public MyList() {
linkedList = new LinkedList();
}
public void add(Object obj) {
linkedList.addFirst(obj);
}
public Object get() {
Object poll = linkedList.poll();
linkedList.addLast(poll);
return poll;
}
}
7.需求:请用LinkedList模拟栈数据结构的集合,并测试
public class MyTest {
public static void main(String[] args) {
//栈的数据结构;先进后出,后进先出
MyList myList = new MyList();
myList.add(100);
myList.add(200);
myList.add(300);
myList.add(400);
myList.add(500);
myList.add(600);
Object obj= myList.get();
System.out.println(obj);
obj = myList.get();
System.out.println(obj);
obj = myList.get();
System.out.println(obj);
obj = myList.get();
System.out.println(obj);
obj = myList.get();
System.out.println(obj);
obj = myList.get();
System.out.println(obj);
}
}
8.需求:ArrayList去除集合中字符串的重复值(字符串的内容相同)
public class MyTest2 {
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add("aaa");
list.add("aaa");
list.add("aaa");
list.add("bbb");
list.add("bbb");
list.add("ccc");
list.add("ccc");
//可以利用创建新集合的方式来去去除集合中的重复元素
ArrayList newList = new ArrayList();
for (int i = 0; i < list.size(); i++) {
Object o = list.get(i);
if(!newList.contains(o)){
newList.add(o);
}
}
System.out.println(newList);
}
}
9. ArrayList 遍历
public class MyTest3 {
public static void main(String[] args) {
Student s1 = new Student("张三", 23);
Student s2 = new Student("张三", 23);
Student s3 = new Student("李四", 24);
Student s4 = new Student("李四", 24);
Student s5 = new Student("王五", 25);
Student s6 = new Student("王五", 25);
ArrayList list = new ArrayList();
list.add(s1);
list.add(s2);
list.add(s3);
list.add(s4);
list.add(s5);
list.add(s6);
ArrayList newList = new ArrayList();
for (int i = 0; i < list.size(); i++) {
Student student= (Student) list.get(i);
if(!newList.contains(student)){
newList.add(student);
}
}
System.out.println("====================");
for (int i = 0; i < newList.size(); i++) {
Object o = list.get(i);
System.out.println(o);
}
}
}
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = 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;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age &&
Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
10. 泛型机制:就是把类型明确工作,推迟到创建对象或调用方法时,再去明确的工作
泛型可以提高代码的扩展性和灵活性
可以把问题提前到编译器,可以避免向下转型。
泛型只在编译期有效,到运行期就擦除了。
泛型可以使用在 类 接口 方法上
public class MyTest {
public static void main(String[] args) {
int[] arr={10,20,30,40,50};
for(int ele:arr){
System.out.println(ele);
}
System.out.println("==============================");
ArrayList<Integer> list = new ArrayList<>();
list.add(200);
list.add(200);
list.add(200);
list.add(200);
list.add(200);
list.add(200);
list.add(200);
list.add(200);
list.add(200);
for(Integer ele:list){
System.out.println(ele);
}
for (int i : arr) {
}
System.out.println("========================");
for (int i = 0; i < list.size(); i++) {
}
for (Integer integer : list) {
}
}
}
11.ConcurrentModificationException
注意新式for循环,你在迭代集合的途中,不能增删元素,会报并发修改异常
public class MyTest2 {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
list.add(200);
list.add(200);
list.add(50);
list.add(200);
list.add(200);
list.add(200);
list.add(200);
list.add(200);
list.add(200);
list.add(200);
for (Integer integer : list) {
}
for (int i = 0; i < list.size(); i++) {
if(i==2){
}
}
}
}
12.把一个集合转成数组、把一个数组转换成集合
public class MyTest2 {
public static void main(String[] args) {
//把一个集合转成数组
ArrayList<Integer> list = new ArrayList<>();
list.add(200);
list.add(200);
list.add(200);
list.add(200);
list.add(200);
list.add(200);
list.add(200);
list.add(200);
list.add(200);
Object[] objects = list.toArray();
System.out.println("=================================");
//把一个数组转换成集合
Integer[] integers = {20, 30, 50};
//当你传进来的是一个数组,他会把数组中的元素 取出来放到集合中
List<Integer> integers1 = Arrays.asList(integers);
for (Integer integer : integers1) {
System.out.println(integer);
}
System.out.println("===========================");
Integer[] integers2 = {20, 30, 50};
Integer[] integers3 = {20, 30, 500};
//当你传进来的是两个以上的数组,那么他是把数组放到集合中
List<Integer[]> list1 = Arrays.asList(integers2, integers3);
for (Integer[] integers4 : list1) {
System.out.println(integers4);
for (Integer integer : integers4) {
System.out.println(integer);
}
}
/* Integer integer = list1.get(1)[2];
System.out.println(integer);*/
System.out.println("===============================");
Integer[] integers4 = {200, 300, 500};
int[] arr={1,2,3};
//当你传进来一个元素是引用类型的数组,那么他会把数组中的元素取出来放到集合中
List<Integer> integers5 = Arrays.asList(integers4);
Integer integer = integers5.get(2);
System.out.println(integer);
//当你传进来是一个基本类型的数组,他是把这个数组放到集合中
List<int[]> ints = Arrays.asList(arr);
int i = ints.get(0)[2];
System.out.println(i);
System.out.println("=========================================");
Integer[] integers6 = {20, 30, 50,60,70};
//通过asList(integers6);转换过来的这个集合,这个集合不能增删元素
List<Integer> list2 = Arrays.asList(integers6);
Integer integer1 = list2.get(0);
System.out.println(integer1);
list2.set(1,300);
System.out.println(list2);
//list2.add(600);
list2.remove(0);
list2.remove(new Integer(20));
//把这些元素放到集合中
List<Integer> integers7 = Arrays.asList(20, 30, 20, 30, 50);
}
}
13.ArrayList嵌套ArrayList
public class MyTest3 {
public static void main(String[] args) {
Student s1 = new Student("张三1", 23);
Student s2 = new Student("张三2", 23);
Student s3 = new Student("张三3", 23);
Student s4 = new Student("张三4", 23);
Student s5 = new Student("张三5", 23);
Student s6 = new Student("张三6", 23);
Student s7 = new Student("张三7", 23);
ArrayList<Student> javaList = new ArrayList<>();
javaList.add(s1);
javaList.add(s2);
javaList.add(s3);
ArrayList<Student> phpList = new ArrayList<>();
phpList.add(s4);
phpList.add(s5);
ArrayList<Student> webList = new ArrayList<>();
javaList.add(s6);
javaList.add(s7);
//这是一个最大的集合,存储三个小集合
//二维集合
ArrayList<ArrayList<Student>> maxList = new ArrayList<>();
maxList.add(javaList);
maxList.add(phpList);
maxList.add(webList);
//遍历最大的集合,打印出每个学生的信息
//普通for循环遍历
for (int i = 0; i < maxList.size(); i++) {
ArrayList<Student> students = maxList.get(i);
for (int j = 0; j < students.size(); j++) {
Student student = students.get(j);
System.out.println(student.getName()+"=="+student.getAge());
}
}
System.out.println("==================================");
for (ArrayList<Student> students : maxList) {
for (Student student : students) {
System.out.println(student.getName() + "==" + student.getAge());
}
}
}
}
public class Student {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = 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;
}
}