大数据之路week02 List集合的子类
1：List集合的子类（掌握）
（1）List的子类特点
ArrayList：
底层数据结构是数组，查询快，增删慢。
线程不安全，效率高。
Vector：
底层数据结构是数组，查询快，增删慢。
线程安全，效率低。
LinkedList：
底层数据结构是链表，查询慢，增删快。
线程不安全，效率高。
（2）ArrayList
A: 没有特有的功能需要学习
B: 案例：
a: ArrayList 存储字符串对象并遍历
package com.wyh.jdkNews; import java.util.ArrayList;
import java.util.Iterator; /**
* @author WYH
* @version 2019年11月16日 上午9:16:23
*
* ArrayList存储字符串并进行遍历，要求加入泛型，并用增强for遍历
*
* 1、迭代器
* 2、普通for循环
* 3、增强for循环
*/
public class ArrayListDemo01 {
public static void main(String[] args) {
ArrayList<String> array = new ArrayList<String>(); array.add("赵以浩");
array.add("王友虎");
array.add("齐博源"); //迭代器
Iterator<String> it = array.iterator();
while(it.hasNext()) {
String s = it.next();
System.out.println(s);
} System.out.println("----------------"); //普通for循环
for(int x = 0;x<array.size();x++) {
String s = array.get(x);
System.out.println(s);
} System.out.println("----------------"); //增强for进行遍历
for(String s : array) {
System.out.println(s);
}
}
}
b: ArrayList存储自定义对象并遍历
学生 Student类：
package com.wyh.jdkNews; /**
* @author WYH
* @version 2019年11月14日 下午7:15:01
*/
public class Student {
private String name;
private int age;
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Student() {
super();
// TODO Auto-generated constructor stub
}
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 boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
} }
测试类：
package com.wyh.jdkNews; import java.util.ArrayList;
import java.util.Iterator; /**
* @author WYH
* @version 2019年11月16日 上午9:16:23
*
* ArrayList存储自定义对象并进行遍历，要求加入泛型，并用增强for遍历
*
* 1、迭代器
* 2、普通for循环
* 3、增强for循环
*/
public class ArrayListDemo02 {
public static void main(String[] args) {
ArrayList<Student> array = new ArrayList<Student>(); //创建学生对象
Student s1 = new Student("小花",18);
Student s2 = new Student("小月",19);
Student s3 = new Student("小王",22);
Student s4 = new Student("小强",24);
Student s5 = new Student("小紫",16); //将学生对象添加到集合中去
array.add(s1);
array.add(s2);
array.add(s3);
array.add(s4);
array.add(s5); //迭代器、
Iterator<Student> it = array.iterator(); while(it.hasNext()) {
Student s = it.next();
System.out.println(s.getName()+"---"+s.getAge());
} System.out.println("---------------"); //普通for循环
for(int i = 0;i<array.size();i++) {
Student s = array.get(i);
System.out.println(s.getName()+"---"+s.getAge());
} System.out.println("----------------"); //增强for循环
for(Student s : array) {
System.out.println(s.getName()+"---"+s.getAge()); } }
}
（3）Vector
A: 特有功能
a: 添加
public void addElement(E obj) 将指定的组件添加到此向量的末尾，将其大小增加1。 ------add()
b：获取
public E elementAt(int index) 返回指定索引处的组件。 -----get()
public Enumberation<E> elements() -----Iterator()
(4)LinkedList
A: 特有的功能
a: 添加
addFirst()
addLast()
b: 删除
removeFirst()
removeLast()
c: 获取
getFirst()
getLast()
B: 案例：
a: LinkedList 存储字符串并且遍历
package com.wyh.LinkedList; import java.util.Iterator;
import java.util.LinkedList; /**
* @author WYH
* @version 2019年11月16日 下午9:40:01
*/
public class LinkedListDemo2 {
public static void main(String[] args) {
//创建集合对象
LinkedList linkList = new LinkedList(); //将学生对象添加到集合中去
linkList.add("aa");
linkList.add("bb");
linkList.add("cc");
linkList.add("dd");
linkList.add("ee"); //创建迭代器对象
Iterator it = linkList.iterator(); while(it.hasNext()) {
String s = (String)it.next();
System.out.println(s);
} }
}
b: LinkedList存储自定义对象并遍历
package com.wyh.LinkedList; import java.util.Iterator;
import java.util.LinkedList; /**
* @author WYH
* @version 2019年11月14日 下午7:14:33
*
* LinkedList 存储对象并遍历。
*/
public class LinkedListDemo1 {
public static void main(String[] args) {
//创建集合对象
LinkedList linkList = new LinkedList(); //创建学生对象
Student s1 = new Student("王友虎",22);
Student s2 = new Student("赵以浩",23);
Student s3 = new Student("李宏灿",21);
Student s4 = new Student("李先锋",22);
Student s5 = new Student("齐博源",23); //将学生对象添加到集合中去
linkList.add(s1);
linkList.add(s2);
linkList.add(s3);
linkList.add(s4);
linkList.add(s5); //创建迭代器对象
Iterator it = linkList.iterator(); while(it.hasNext()) {
Student s = (Student)it.next();
System.out.println(s.getName()+"------"+s.getAge());
} } }
（5）案例；
A: 去除集合中的多个字符串的重复元素
如果字符串的内容相同，即为重复元素。
a: 思路1:创建一个新的集合，依次遍历旧集合，如果新集合里没有该元素，就添加，反之，有就不添加。
package com.wyh.LinkedList; import java.util.ArrayList;
import java.util.Iterator; /**
* @author WYH
* @version 2019年11月14日 下午8:53:32
*
* 去除ArrayList中的重复字符串对象
* 思路1:创建一个新的集合，依次遍历旧集合，如果新集合里没有该元素，就添加，反之，有就不添加。
*/
public class ArrayListDemo4 {
public static void main(String[] args) {
//创建集合对象
ArrayList a = new ArrayList(); a.add("AAA");
a.add("BBB");
a.add("CCC");
a.add("AAA");
a.add("AAA");
a.add("AAA");
a.add("BBB");
a.add("CCC"); //创建迭代器
Iterator it = a.iterator(); //创建一个新的集合
ArrayList newa = new ArrayList(); while(it.hasNext()) {
String s = (String) it.next();
if(!(newa.contains(s))) {
newa.add(s);
}
} //遍历
Iterator it1 = newa.iterator();
while(it1.hasNext()) {
String s = (String)it1.next();
System.out.println(s);
} } }
b: 不创建新的集合，就在以前的集合上做。选择排序的思想
package com.wyh.LinkedList; import java.util.ArrayList; /**
* @author WYH
* @version 2019年11月14日 下午8:53:39
*
* 去除ArrayList中的重的字符串对象
* 思路2:不创建新的集合，就在以前的集合上做。选择排序的思想
*/
public class ArrayListDemo5 {
public static void main(String[] args) {
//创建集合对象
ArrayList a = new ArrayList(); a.add("AAA");
a.add("BBB");
a.add("CCC");
a.add("AAA");
a.add("AAA");
a.add("AAA");
a.add("BBB");
a.add("CCC"); for(int i = 0;i<a.size()-1;i++) {
for(int j = i+1;j<a.size();j++) {
if(a.get(i).equals(a.get(j))) {
a.remove(j);
j--;
}
}
} //遍历
for(int i = 0;i<a.size();i++) {
String s = (String)a.get(i);
System.out.println(s);
}
} }
B: 去除集合中的多个自定义对象的重复元素
如果自定义对象的成员变量值都相同，即为重复元素。
知识扩展：
contains方法的底层是equals方法，所以不能用这个进行比较。
* 而我们学生类里面没有equals方法，所以这时候就默认使用的是它父亲(Object)的equals方法。
* 而Object的equals方法，默认比较的是地址值,又因为，new的地址值都不同，所以用equals比较总是失败。
* 怎么解决？
* 重写equals方法
重写后的Student类；
package com.wyh.LinkedList; /**
* @author WYH
* @version 2019年11月14日 下午7:15:01
*/
public class Student {
private String name;
private int age;
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Student() {
super();
// TODO Auto-generated constructor stub
}
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 boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
} }
思路1:创建一个新的集合，依次遍历旧集合，如果新集合里没有该元素，就添加，反之，有就不添加。
package com.wyh.LinkedList; import java.util.ArrayList;
import java.util.Iterator; /**
* @author WYH
* @version 2019年11月14日 下午7:28:06
*
* 去除ArrayList中的重复对象
* 思路1:创建一个新的集合，依次遍历旧集合，如果新集合里没有该元素，就添加，反之，有就不添加。
*
* contains方法的底层是equals方法，所以不能用这个进行比较。
* 而我们学生类里面没有equals方法，所以这时候就默认使用的是它父亲(Object)的equals方法。
* 而Object的equals方法，默认比较的是地址值,又因为，new的地址值都不同，所以用equals比较总是失败。
* 怎么解决？
* 重写equals方法
*
*/
public class ArrayListDemo2 {
public static void main(String[] args) {
//创建集合对象
ArrayList aList = new ArrayList(); //创建学生对象
Student s1 = new Student("齐博源",22);
Student s2 = new Student("王友虎",22);
Student s3 = new Student("赵以浩",24);
Student s4 = new Student("李先锋",24);
Student s5 = new Student("李宏灿",22);
Student s6 = new Student("李宏灿",22);
Student s7 = new Student("赵以浩",24);
Student s8 = new Student("齐博源",22); //将学生对象添加到集合中去
aList.add(s1);
aList.add(s2);
aList.add(s3);
aList.add(s4);
aList.add(s5);
aList.add(s6);
aList.add(s7);
aList.add(s8); //创建一个新的集合
ArrayList aList2 = new ArrayList(); //使用迭代器进行遍历
Iterator it = aList.iterator(); while(it.hasNext()) {
Student s = (Student)it.next();
System.out.println(s.getName()+"---"+s.getAge());
if(!aList2.contains(s)) {
aList2.add(s); }
} System.out.println("----------去重后-----------"); //遍历新集合
Iterator it2 = aList2.iterator();
while(it2.hasNext()) {
Student s = (Student)it2.next();
System.out.println(s.getName()+"---"+s.getAge());
} } }
思路2:不创建新的集合，就在以前的集合上做。选择排序的思想
package com.wyh.LinkedList; import java.util.ArrayList;
import java.util.Iterator; /**
* @author WYH
* @version 2019年11月14日 下午8:09:35
*
*
* 去除ArrayList中的重复对象
* 思路2:不创建新的集合，就在以前的集合上做。选择排序的思想
*/
public class ArrayListDemo3 {
public static void main(String[] args) {
//创建集合对象
ArrayList aList = new ArrayList(); //创建学生对象
Student s1 = new Student("齐博源",22);
Student s2 = new Student("王友虎",22);
Student s3 = new Student("赵以浩",24);
Student s4 = new Student("李先锋",24);
Student s5 = new Student("李宏灿",22);
Student s6 = new Student("赵以浩",24);
Student s7 = new Student("王友虎",22);
Student s8 = new Student("齐博源",22); //将学生对象添加到集合中去
aList.add(s1);
aList.add(s2);
aList.add(s3);
aList.add(s4);
aList.add(s5);
aList.add(s6);
aList.add(s7);
aList.add(s8); for(int i = 0 ;i<aList.size()-1;i++) {
for(int j = i+1;j<aList.size();j++) {
if(aList.get(i).equals(aList.get(j))) {
aList.remove(j);// 移除后一个会把前面顶掉，移除第六个，j=5,就不再小于size了
j--;
}
}
} for(int i = 0;i<aList.size();i++) {
Student s = (Student)aList.get(i);
System.out.println(s.getName()+"---"+s.getAge());
}
} }
C: 用LInkedlIst模拟一个栈数据结构的集合类（面试题！！）
创建我们模拟LinkedList的类：
package com.wyh.LinkedList; import java.util.Iterator;
import java.util.LinkedList; /**
* @author WYH
* @version 2019年11月14日 下午9:28:24
*
* 利用LinkedList模拟栈数据结构的集合测试
*
*/
public class MyStack01 { private LinkedList list; public MyStack01() {
this.list = new LinkedList();
} //添加功能
public void add(Object obj) {
list.addFirst(obj);
} //获取功能
public Object get() {
// return list.getFirst();
return list.removeFirst(); //删除栈顶元素，并且返回被删除的元素.
} public Iterator iterator() {
// TODO Auto-generated method stub
return list.iterator();
} public int size() {
// TODO Auto-generated method stub
return list.size();
} public boolean isEmpty() {
return list.isEmpty();
} }
创建测试类：
package com.wyh.LinkedList; import java.util.Iterator; /**
* @author WYH
* @version 2019年11月14日 下午9:36:12
*/
public class MyStackTest01 {
public static void main(String[] args) {
MyStack01 ms = new MyStack01(); ms.add("123");
ms.add("321");
ms.add("789"); /*for(int i = ms.size();i>0;i--) {
System.out.println(ms.get());
}*/ //while循环
while(!ms.isEmpty()) {
System.out.println(ms.get());
} /*//for循环
for(int i = 0;i<=ms.size()+1;i++) {
System.out.println(ms.get());
}*/ /* //创建迭代器
Iterator it = ms.iterator(); while(it.hasNext()) {
String s = (String)it.next();
System.out.println(s);
}*/ } }
2、泛型（掌握）
（1）泛型概述
是一种把明确类型的工作推迟到创建对象或者调用该方法的时候才去明确的特殊类型
（2）格式
<数据类型>
注意： 该数据类型只能是引用类型
（3）好处：
A: 把运行时期出现的问题提前到了编译时期
B: 避免了强制类型转换
C: 优化了程序设计，解决了黄色警告线的问题，让程序更加的安全。
（4）泛型的前生今世
A: 泛型的由来
早期的时候，我们使用Object来表示任意类型。
向下转型的时候是没有任何问题的，但是在向下转型的时候隐含了转型的问题。
也就是说这样的程序时不安全的，所以Java在JDK1.5的之后，引入了泛型，提高系统的安全性。
Object类型作为任意类型的时候，在向下转型的时候，会隐含一个转型问题。
B: 泛型类
泛型类：
package com.wyh.Object; /**
* @author WYH
* @version 2019年11月15日 下午9:09:39
*
* 把泛型应用在类上,泛型类
*/
public class ObjectTool02<T> {
private T obj; public T getObj() {
return obj;
} public void setObj(T obj) {
this.obj = obj;
} }
泛型类的测试：
package com.wyh.Object; /**
* @author WYH
* @version 2019年11月15日 下午9:11:09
*
* 泛型类测试
*/
public class ObjectToolDemo02 {
public static void main(String[] args) {
ObjectTool02<String> obj = new ObjectTool02<String>();
//obj.setObj(new Integer(2));//编译的时候就会报错
obj.setObj(new String("小虎"));
String i = obj.getObj();
System.out.println(i); ObjectTool02<Integer> obj2 = new ObjectTool02<Integer>();
//obj2.setObj(new String("xiaohu")); //编译的时候就会报错
obj2.setObj(new Integer(23));
Integer j = obj2.getObj();
System.out.println(j); }
}
C: 泛型方法
泛型方法，类上不加泛型，在方法中添加：
package com.wyh.Object; /**
* @author WYH
* @version 2019年11月15日 下午9:26:17
*
* 泛型方法
*
*/ //泛型方法
public class ObjectTool03 {
public <T> void show(T t) {
System.out.println(t);
}
}
测试：
package com.wyh.Object; /**
* @author WYH
* @version 2019年11月15日 下午9:28:22
*/
public class ObjectToolDemo03 {
public static void main(String[] args) {
//问题1
/*ObjectTool03 obj = new ObjectTool03();
obj.show("王友虎");
obj.show(123);
obj.show(true);*/ //问题2
/*ObjectTool03<String> obj = new ObjectTool03<String>();
obj.show("王友虎");
//obj.show(123);
//obj.show(true);
*/ //问题3、如果到这还听得懂，说明泛型类是没有问题的
//但是，我现在定义的类和方法的类型是一致的，谁说过一定要一致的呢？
//如果类上没有定义泛型的话，那么还能不能接收任意类型的呢？（答案是肯定可以的，泛型方法）ObjectTool03 第二段代码
ObjectTool03 obj = new ObjectTool03();
obj.show("王友虎");
obj.show(123);
obj.show(true); } }
D: 泛型接口
创建泛型接口：
package com.wyh.Object; /**
* @author WYH
* @version 2019年11月15日 下午9:46:16
*
* 泛型接口
*/
public interface Inter<T> {
public abstract void show(T t);
}
创建实现类将接口实现：
package com.wyh.Object; /**
* @author WYH
* @version 2019年11月15日 下午9:47:30
*/ //第一种情况，我们在实现的时候就知道是什么类型的了。
/*public class InterImpl implements Inter<String>{ @Override
public void show(String s) {
System.out.println(s); }
}*/ //第二种情况，
public class InterImpl<T> implements Inter<T>{ @Override
public void show(T t) {
System.out.println(t); }
}
创建测试类进行测试：
package com.wyh.Object; /**
* @author WYH
* @version 2019年11月15日 下午9:48:09
*/
public class InterTest {
public static void main(String[] args) { /*//第一种情况测试
Inter<String> inte = new InterImpl();
inte.show("王友虎");*/ //第一种情况测试
Inter<String> inte = new InterImpl<String>();
inte.show("王友虎"); Inter<Integer> inte1 = new InterImpl<Integer>();
inte1.show(123); } }
E: 泛型高级之通配符
?: 任意类型，如果没有明确，那就是Object类型以及任意的Java类了
? extends E: 向下限定，限定E 及其子类
? super E: 向上限定，限定E 及其父类
package com.wyh.generic; import java.util.ArrayList;
import java.util.Collection; /**
* @author WYH
* @version 2019年11月15日 下午10:00:39
*
* 泛型之高级通配符
*
* ?: 任意类型，如果没有明确，那就是Object类型以及任意的Java类了
* ? extends E: 向下限定，限定E 及其子类
* ? super E: 向上限定，限定E 及其父类
*/ class Animal{ } class Dog extends Animal{ } class Cat extends Animal{ } public class GenericDemo1 {
public static void main(String[] args) { // 泛型如果明确写的时候，前后必须一致！
Collection<Object> c1 = new ArrayList<Object>();
/*
* Collection<Object> c2 = new ArrayList<Animal>(); Collection<Object> c3 = new
* ArrayList<Dog>(); Collection<Object> c4 = new ArrayList<Cat>();
*/ // ? 表示任一类型是可以滴
Collection<?> c5 = new ArrayList<Object>();
Collection<?> c2 = new ArrayList<Animal>();
Collection<?> c3 = new ArrayList<Dog>();
Collection<?> c4 = new ArrayList<Cat>(); // ? extends E: 向下限定，限定E 及其子类
// Collection<? extends Animal> c6 = new ArrayList<Object>(); //报错
Collection<? extends Animal> c7 = new ArrayList<Dog>();
Collection<? extends Animal> c8 = new ArrayList<Cat>();
Collection<? extends Animal> c9 = new ArrayList<Animal>(); // ? super E: 向上限定，限定E 及其父类
Collection<? super Animal> c10 = new ArrayList<Object>();
Collection<? super Animal> c13 = new ArrayList<Animal>();
// Collection<? super Animal> c11 = new ArrayList<Dog>(); //报错
// Collection<? super Animal> c12 = new ArrayList<Cat>(); }
}
3、增强for循环（掌握）增强for其实就是来替代器迭代器的，怎么验证？ 并发修改异常
（1）是for循环的一种
（2）格式：
for(元素的数据类型 变量名 ：数组或者Collection集合的对象){
使用该变量即可，该变量其实就是数组或者集合中的元素。
}
（3）好处：
简化了数组和集合的遍历
（4）弊端
增强for循环的目标不能为null。建议在使用前，现判断是否为null。
package com.wyh.jdkNews; import java.util.ArrayList;
import java.util.List; /**
* @author WYH
* @version 2019年11月16日 上午8:44:59
*
* JDK5 的新特性: 自动装箱，泛型，增强for，静态导入，可变参数，枚举
*
* 增强for: for循环
* 格式:
* for(元素数据类型 变量名 : 数组或者是Collection 集合){
* 变量，直接使用
* }
*
* 好处: 简化了数组和集合的遍历
*
* 弊端: 增强for的目标不能为null
* 解决: 在进行增强for之前我们要先进行不为null的判断
*/
public class ForDemo01 {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5}; for(int x = 0;x<arr.length;x++) {
System.out.println(arr[x]);
} System.out.println("---------------"); for(int x:arr) {
System.out.println(x);
} System.out.println("---------------"); //定义一个字符串数组
String[] arrayList = {"小虎","小沛","小王"};
for(String array : arrayList) {
System.out.println(array); } System.out.println("---------------");
// 定义一个ArrayList
ArrayList<String> array = new ArrayList<String>();
array.add("林青霞");
array.add("刘亦菲");
array.add("景甜"); for (String array1 : array) {
System.out.println(array1); } System.out.println("---------------"); //NullPointerException报空指针错误
// List<String> list = null;
if (list != null) {
for (String x : list) {
System.out.println(x);
}
} System.out.println("---------------");
//增强for其实就是来替代器迭代器的，怎么验证？ 并发修改异常。ConcurrentModificationException
for (String array1 : array) {
if("刘亦菲".equals(array1)) {
array.add("小王");
} }
System.out.println("array1:"+array); } }
4、静态导入（了解）
（1）可以导入到方法级别的导入
（2）格式
import static 包名....类名.方法名;
（3）注意事项：
A: 方法必须是静态的
B：如果多个类下有同名的方法，就不好区分了。还得加上前缀，所以一般我们并不使用静态导入，但是一定要能够看得懂。
package com.wyh.StaticImport; /**
* @author WYH
* @version 2019年11月16日 上午9:40:42
* 静态导入
*
* 格式: import static 包名....类名.方法名
* 可以直接导入到方法级别
*/
import static java.lang.Math.abs;
import static java.lang.Math.pow;
import static java.lang.Math.max; public class StaticImportDemo01 {
public static void main(String[] args) { System.out.println(java.lang.Math.abs(100));
System.out.println(java.lang.Math.pow(2, 4));
System.out.println(java.lang.Math.max(10, 50));
//太复杂 System.out.println(Math.abs(100));
System.out.println(Math.pow(2, 4));
System.out.println(Math.max(10, 50));
//依旧太复杂 System.out.println(abs(100));
System.out.println(pow(2, 4));
System.out.println(java.lang.Math.max(10, 50));
//静态导包
} private static void max(int i) {//底层源码就是数组
System.out.println(i);
}
}
5、可变参数（掌握）
（1）如果我们在写方法的时候，参数个数不明确，就应该定义可变参数。
（2）格式：
修饰符 返回值类型 方法名（数据类型... 变量）{ }
注意：
A: 该变量其实是一个数组名
B: 如果一个方法有多个参数，并且有可变参数，可变参数必须在最后。
（3）Arrays工具类的一个方法
asList()把数组转成集合
注意: 这个集合的长度不能改变。
package com.wyh.args; /**
* @author WYH
* @version 2019年11月16日 上午9:52:41
*
* 可变参数:
* 访问修饰符 返回值 方法名(数据类型... 变量名){
*
* }
*
* 1.这里的变量名是一个数组
* 2.如果一个方法拥有可变参数,并且拥有多个参数,那么可变参数是放在最后一个。
*
*
* 需求:我要写一个求和函数,具体几个数据求和我并不清楚,但是我在调用的时候就知道了.
* 为了解决这个问题,Java就提供了一个东西: 可变参数
*/
public class ArgsDemo01 {
public static void main(String[] args) {
//两个数据的求和
int a = 10;
int b = 20;
int result = sum(a, b);
System.out.println("result:"+result); //三个数据的求和
int c = 30;
int result2 = sum(a,b,c);
System.out.println("result:"+result2); //四个数据的求和
int d = 40;
int result3 = sum(a,b,c,d);
System.out.println("result:"+result3); } //可变参数
private static int sum(int... a) {//底层源码就是数组
int s = 0;
for(int x : a) {
s += x;
}
return s;
} /* private static int sum(int a, int b,int c,int d) {
return a+b+c+d;
} private static int sum(int a, int b,int c) {
return a+b+c;
} private static int sum(int a, int b) {
return a+b;
}*/ }
package com.wyh.args; import java.util.Arrays;
import java.util.List; /**
* @author WYH
* @version 2019年11月16日 上午10:15:37
*
* static <T> List<T> asList(T... a) :把数组转成一个集合
* 注意：
* 虽然是把一个数组转成一个集合，但是其本质是数组，所以，它的长度固定
*/
public class ArraysDemo01 {
public static void main(String[] args) {
String[] s = {"小虎","小花","小美"}; List<String> list = Arrays.asList(s);
// UnsupportedOperationException
// list.add("123");
// UnsupportedOperationException
// list.remove(1);
list.set(1,"小雪"); //可以进行修改 for(String s1 : list) {
System.out.println(s1);
}
} }
6、练习（掌握）
A: 集合的嵌套遍历。
先来看看逻辑图：
代码实现：（学生类不重复给出了）
package com.wyh.list_son_test; import java.util.ArrayList; /**
* @author WYH
* @version 2019年11月16日 上午10:28:03
*
* 集合的嵌套遍历
*
* 需求：
* 我们班里有学生，每一个学生可以看作是一个对象，可以使用一个集合来表示我们一个班的学生 ，ArrayList<Student>
* 但是呢，隔壁也有一个班级，也同样拥有一个ArrayList<Student>来表示一个班的学生
* 而我们现在有多个ArrayList<Student>，也是要用集合来进行存储，怎么办呢？
* 其实就是 ArrayList<ArrayList<Student>>
*/
public class ArrayListDemo01 {
public static void main(String[] args) {
//创建大集合对象
ArrayList<ArrayList<Student>> bigArrayList = new ArrayList<ArrayList<Student>>(); //创建第一个班级
ArrayList<Student> firstArrayList = new ArrayList<Student>();
//创建学生对象
Student s1 = new Student("唐三藏",30);
Student s2 = new Student("孙悟空",29);
Student s3 = new Student("猪八戒",28);
Student s4 = new Student("白龙马",27);
Student s5 = new Student("沙悟净",26);
//将学生对象添加到集合中去
firstArrayList.add(s1);
firstArrayList.add(s2);
firstArrayList.add(s3);
firstArrayList.add(s4);
firstArrayList.add(s5);
//再将这个班级放到学生系统中去
bigArrayList.add(firstArrayList); //创建第二个班级
ArrayList<Student> secondArrayList = new ArrayList<Student>();
//创建学生对象
Student s11 = new Student("刘备",40);
Student s22 = new Student("关羽",38);
Student s33 = new Student("张飞",35);
//将学生对象添加到集合中去
secondArrayList.add(s11);
secondArrayList.add(s22);
secondArrayList.add(s33);
//再将这个班级放到学生系统中去
bigArrayList.add(secondArrayList); //创建第三个班级
ArrayList<Student> thirdArrayList = new ArrayList<Student>();
//创建学生对象
Student s111 = new Student("宋江",29);
Student s222 = new Student("鲁智深",45);
Student s333 = new Student("武松",28);
//将学生对象添加到集合中去
thirdArrayList.add(s111);
thirdArrayList.add(s222);
thirdArrayList.add(s333);
//再将这个班级放到学生系统中去
bigArrayList.add(thirdArrayList); //增强for循环进行遍历
for(ArrayList<Student> array : bigArrayList) {
System.out.println("---------");
for(Student i : array) {
System.out.println(i.getName()+"---"+i.getAge());
}
} } }
B: 产生10个1-20之间的随机数，要求随机数不能重复。
package com.wyh.random; import java.util.ArrayList;
import java.util.Random; /**
* @author WYH
* @version 2019年11月16日 上午11:13:17
* 随机产生10个1-20之间的数，不能重复
*
* 可以用集合实现
*
* 1、创建产生随机数对象
* 2、创建存储产生随机数的集合
* 3、创建统计随机数个数的变量，从0 开始
* 4、判断统计变量是否小于10，
* 是:不搭理它，跳过
* 不是: 先产生一个随机数，判断在集合中是否存在，
* 存在: 不搭理他
* 不存在: 进行添加，统计变量+1
*
*/
public class RandomDemo01 {
public static void main(String[] args) {
//创建产生随机数对象
Random r = new Random(); //创建存储产生随机数的集合
ArrayList<Integer> array = new ArrayList<Integer>(); //创建统计随机数个数的变量，从0 开始
int count = 0; //判断统计变量是否小于10，
while(count<10) {
int number = r.nextInt(20)+1; //r.nextInt(20) 范围在0-19 对他进行+1 保证在1-20
if(!array.contains(number)) {
array.add(number);
count++;
}
} for(Integer i : array) {
System.out.println(i);
} } }
C: 键盘录入多个数据，以0结束，并在控制台输出最大值。
package com.wyh.random; import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner; /**
* @author WYH
* @version 2019年11月16日 下午3:20:33
*/
public class ScannerDemo01 {
public static void main(String[] args) {
//创建控制台输入对象
Scanner sc = new Scanner(System.in); //创建存储从控制台输入的数的集合
ArrayList<Integer> array = new ArrayList<Integer>(); boolean flag = true; while(flag) {
// 友情提示
System.out.print("请输入所要存储的数据,输入 0 表示停止:");
int number = sc.nextInt();
if(number==0) {
flag = false;
}else if(!array.contains(number)){
array.add(number);
}
} Object[] obj = array.toArray();
Arrays.sort(obj);
for(Object x : obj) {
System.out.print(x+" ");
}
System.out.println("您录入的最大值是:"+obj[obj.length-1]); /* //遍历集合
System.out.print("您总共存入的数据有:");
for(Integer i : array) {
System.out.print(i+" ");
}*/ } }
7、总之，学完这一节需要掌握的代码有：
集合存储元素，加入泛型，并且可以使用增强for循环遍历
大数据之路week02 List集合的子类的更多相关文章
- 大数据之路week02 Collection 集合体系收尾(Set)
1.Set集合(理解) (1)Set集合的特点 无序,唯一. (2)HashSet集合(掌握) A: 底层数据结构是哈希表(是一个元素为链表的数组) B: 哈希表底层依赖两个方法: hashCode( ...
- 大数据之路week02--day03 Map集合、Collections工具类的用法
1.Map(掌握) (1)将键映射到值的对象.一个映射不能包含重复的键:每个键最多只能映射到一个值. (2)Map和Collection的区别? A: Map 存储的是键值对形式的元素,键唯一,值可以 ...
- 黑马基础阶段测试题：创建一个存储字符串的集合list，向list中添加以下字符串：”C++”、”Java”、” Python”、”大数据与云计算”。遍历集合，将长度小于5的字符串从集合中删除，删除成功后，打印集合中的所有元素
package com.swift; import java.util.ArrayList; import java.util.List; import java.util.ListIterator; ...
- 大数据之路week01--自学之集合_1（Collection）
经过我个人的调查,发现,在今后的大数据道路上,集合.线程.网络编程变得尤为重要,为什么? 因为大数据大数据,我们必然要对数据进行处理,而这些数据往往是以集合形式存放,掌握对集合的操作非常重要. 在学习 ...
- 大数据之路week04--day06（I/O流阶段一 之异常）
从这节开始,进入对I/O流的系统学习,I/O流在往后大数据的学习道路上尤为重要!!!极为重要,必须要提起重视,它与集合,多线程,网络编程,可以说在往后学习或者是工作上,起到一个基石的作用,没了地基,房 ...
- 胖子哥的大数据之路（9）-数据仓库金融行业数据逻辑模型FS-LDM
引言: 大数据不是海市蜃楼,万丈高楼平地起只是意淫,大数据发展还要从点滴做起,基于大数据构建国家级.行业级数据中心的项目会越来越多,大数据只是技术,而非解决方案,同样面临数据组织模式,数据逻辑模式的问 ...
- 胖子哥的大数据之路（6）- NoSQL生态圈全景介绍
引言: NoSQL高级培训课程的基础理论篇的部分课件,是从一本英文原著中做的摘选,中文部分参考自互联网.给大家分享. 正文: The NoSQL Ecosystem 目录 The NoSQL Eco ...
- 大数据之路week04--day03（网络编程）
哎,怎么感觉自己变得懒了起来,更新博客的频率变得慢了起来,可能是因为最近得知识开始变得杂变得难了起来,之前在上课的时候,也没有好好听这一方面的知识,所以,现在可以说是在学的新的知识,要先去把新的知识思 ...
- 大数据之路week03--day05（线程 I）
真的,身体这个东西一定要爱护好,难受的时候电脑都不想去碰,尤其是胃和肾... 这两天耽误了太多时间,今天好转了立刻学习,即刻不能耽误!. 话不多说,说正事: 1.多线程(理解) (1)多线程:一个应用 ...
随机推荐
- CenOS 7 安装JDK
1.输入安装命令 yum install java-1.8.0-openjdk-devel.x86_64
- AI新生代“教父”崛起，或成就迈向具有类人意识机器的一大步
<麻省理工科技评论>公布了 2018 年全球十大突破性技术,“对抗性神经网络”即“生成对抗网络”作为突破性人工智能技术赫然上榜.这家全球最顶级科技杂志编辑部对这项革命性技术给出的评价是:它 ...
- js 数组去重、去空（收藏）
function unique (arr) { return Array.from(new Set(arr)) } var arr = [1,1,'true','true',true,true,15, ...
- 什么是H5？
总听到很多人说H5,现在H5很火,到底H5是什么,以下发表个人对H5的理解. HTML5 将成为 HTML.XHTML 以及 HTML DOM 的新标准. HTML 的上一个版本诞生于 1999 年. ...
- [转帖]详解JVM内存布局及GC原理，值得收藏
概述 https://www.toutiao.com/i6731345429574713868/ java发展历史上出现过很多垃圾回收器,各有各的适应场景,不仅仅是开发,作为运维也需要对这方面有一定的 ...
- PHP常量：define()和const的区别
常量,就是一个用于存储“不会(也不允许)变化的数据”的标识符.比如圆周率,在一定的应用场景中,就是一个固定的值(人为规定为某个值).常量默认大小写敏感.通常常量标识符总是大写的. (1)define( ...
- python学习-18 元组
tuple 1.元组tuple类似列表,由小括号()括住,其中的元素不可被修改,不能被增加或删除. tu = (222,222123123,("小胡子",444),12341,&q ...
- WUST 设计模式 实验九 观察者模式的应用
实验九 观察者模式的应用 一.实验目的 掌握外观模式(Observer)的特点: 分析具体问题,使用外观模式进行设计. 二.实验内容和要求 网上商店中如果商品(product)在名称(name). ...
- 1269: 划分数（Java）
WUSTOJ 1269: 划分数 参考博客 果7的博客 题目 将 1 个数 n 分成 m 份,求划分的种数.更多内容点击标题. 分析 唯一需要注意的地方是不考虑顺序.其他的直接看代码即可. 代 ...
- SSM集成
SSM集成 Spring和各个框架的整合 Spring目前是JavaWeb开发中最终的框架,提供一站式服务,可以其他各个框架整合集成 Spring整合方案 SSH Ssh是早期的一种整 ...