16（03）总结增强for循环,静态导入,可变参数

package cn.itcast_01;
import java.util.ArrayList;
import java.util.List;
/*
 * JDK5的新特性：自动拆装箱,泛型,增强for,静态导入,可变参数,枚举
 * 
 * 增强for:是for循环的一种。
 * 
 * 格式：
 *  for(元素数据类型 变量名: 数组名或者Collection集合) {
 * 使用变量名即可，该变量就是数组或者集合中的元素
 *    }
 *   
 * 好处：简化了数组和集合的遍历。
 * 
 * 弊端： 增强for的目标不能为null。
 * 如何解决呢?对增强for的目标先进行不为null的判断，然后在使用。
 */
public class ForDemo {
 public static void main(String[] args) {
 // 定义一个int数组
 int[] arr = { 1, 2, 3, 4, 5 };
 for (int x = 0; x < arr.length; x++) {
 System.out.println(arr[x]);
 }
 System.out.println("---------------");
 // 增强for
 for (int x : arr) {
 System.out.println(x);
 }
 System.out.println("---------------");
 // 定义一个字符串数组
 String[] strArray = { "林青霞", "风清扬", "东方不败", "刘意" };
 // 增强for
 for (String s : strArray) {
 System.out.println(s);
 }
 System.out.println("---------------");
 // 定义一个集合
 ArrayList<String> array = new ArrayList<String>();
 array.add("hello");
 array.add("world");
 array.add("java");
 // 增强for
 for (String s : array) {
 System.out.println(s);
 }
 System.out.println("---------------");
 List<String> list = null;
 // NullPointerException
 // 这个s是我们从list里面获取出来的，在获取前，它肯定还好做一个判断
 // 说白了，这就是迭代器的功能
 if (list != null) {
 for (String s : list) {
 System.out.println(s);
 }
 }
 // 增强for其实是用来替代迭代器的
 //ConcurrentModificationException
 // for (String s : array) {
 // if ("world".equals(s)) {
 // array.add("javaee");
 // }
 // }
 // System.out.println("array:" + array);
 }
}

package cn.itcast_01;
import java.util.ArrayList;
import java.util.Iterator;
/*
 * ArrayList存储字符串并遍历。要求加入泛型，并用增强for遍历。
 * A:迭代器
 * B:普通for
 * C:增强for
 */
public class ArrayListDemo {
 public static void main(String[] args) {
 // 创建集合对象
 ArrayList<String> array = new ArrayList<String>();
 // 创建并添加元素
 array.add("hello");
 array.add("world");
 array.add("java");
 // 遍历集合
 // 迭代器
 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);
 }
 }
}

package cn.itcast_01;（1）
public class Student {
 // 成员变量
 private String name;
 private int age;
 // 构造方法
 public Student() {
 super();
 }
 public Student(String name, int age) {
 super();
 this.name = name;
 this.age = age;
 }
 // 成员方法
 // getXxx()/setXxx()
 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;
 }
}
package cn.itcast_01;（2）
import java.util.ArrayList;
import java.util.Iterator;
/*
 * 需求：ArrayList存储自定义对象并遍历。要求加入泛型，并用增强for遍历。
 * A:迭代器
 * B:普通for
 * C:增强for
 * 
 * LinkedList,Vector,Colleciton,List等存储我还讲吗?不讲解了，但是要求你们练习。
 * 
 * 增强for是用来替迭代器。
 */
public class ArrayListDemo2 {
 public static void main(String[] args) {
 // 创建集合对象
 ArrayList<Student> array = new ArrayList<Student>();
 // 创建学生对象
 Student s1 = new Student("林青霞", 27);
 Student s2 = new Student("貂蝉", 22);
 Student s3 = new Student("杨玉环", 24);
 Student s4 = new Student("西施", 21);
 Student s5 = new Student("王昭君", 23);
 // 把学生对象添加到集合中
 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 x = 0; x < array.size(); x++) {
 Student s = array.get(x);
 System.out.println(s.getName() + "---" + s.getAge());
 }
 System.out.println("---------------");
 // 增强for
 for (Student s : array) {
 System.out.println(s.getName() + "---" + s.getAge());
 }
 }
}

package cn.itcast_02;
/*
 * 静态导入：
 * 格式：import static 包名….类名.方法名;
 * 可以直接导入到方法的级别
 * 
 * 静态导入的注意事项：
 *  A:方法必须是静态的
 *  B:如果有多个同名的静态方法，容易不知道使用谁?这个时候要使用，必须加前缀。由此可见，意义不大，所以一般不用，但是要能看懂。
 */
import static java.lang.Math.abs;
import static java.lang.Math.pow;
import static java.lang.Math.max;
//错误
//import static java.util.ArrayList.add;
public class StaticImportDemo {
 public static void main(String[] args) {
 // System.out.println(java.lang.Math.abs(-100));
 // System.out.println(java.lang.Math.pow(2, 3));
 // System.out.println(java.lang.Math.max(20, 30));
 // 太复杂，我们就引入到import
 // System.out.println(Math.abs(-100));
 // System.out.println(Math.pow(2, 3));
 // System.out.println(Math.max(20, 30));
 // 太复杂，有更简单
// System.out.println(abs(-100));
 System.out.println(java.lang.Math.abs(-100));
 System.out.println(pow(2, 3));
 System.out.println(max(20, 30));
 }
 public static void abs(String s){
 System.out.println(s);
 }
}

package cn.itcast_03;
/*
 * 可变参数：定义方法的时候不知道该定义多少个参数
 * 格式：
 *  修饰符 返回值类型 方法名(数据类型…  变量名){
 * 
 *  }
 * 
 *  注意：
 *  这里的变量其实是一个数组
 *  如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个
 */ 
public class ArgsDemo {
 public static void main(String[] args) {
 // 2个数据求和
 int a = 10;
 int b = 20;
 int result = sum(a, b);
 System.out.println("result:" + result);
 // 3个数据的求和
 int c = 30;
 result = sum(a, b, c);
 System.out.println("result:" + result);
 // 4个数据的求和
 int d = 30;
 result = sum(a, b, c, d);
 System.out.println("result:" + result);
 // 需求：我要写一个求和的功能，到底是几个数据求和呢，我不太清楚，但是我知道在调用的时候我肯定就知道了
 // 为了解决这个问题，Java就提供了一个东西：可变参数
 result = sum(a, b, c, d, 40);
 System.out.println("result:" + result);
 result = sum(a, b, c, d, 40, 50);
 System.out.println("result:" + result);
 }
 public static int sum(int... a) {
 // System.out.println(a);
 //return 0;
 int s = 0;
 for(int x : a){
 s +=x;
 }
 return s;
 }
 // public static int sum(int a, int b, int c, int d) {
 // return a + b + c + d;
 // }
 //
 // public static int sum(int a, int b, int c) {
 // return a + b + c;
 // }
 //
 // public static int sum(int a, int b) {
 // return a + b;
 // }
}

package cn.itcast_03;
import java.util.Arrays;
import java.util.List;
/*
 * public static <T> List<T> asList(T... a):把数组转成集合
 * 
 * 注意事项：
 *  虽然可以把数组转成集合，但是集合的长度不能改变。
 */
public class ArraysDemo {
 public static void main(String[] args) {
 // 定义一个数组
 // String[] strArray = { "hello", "world", "java" };
 // List<String> list = Arrays.asList(strArray);
 List<String> list = Arrays.asList("hello", "world", "java");
 // UnsupportedOperationException
 // list.add("javaee");
 // UnsupportedOperationException
 // list.remove(1);
 list.set(1, "javaee");
 for (String s : list) {
 System.out.println(s);
 }
 }
}

package cn.itcast_01;（1）
public class Student {
 private String name;
 private int age;
 public Student() {
 super();
 }
 public Student(String name, int age) {
 super();
 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;
 }
}

import java.util.ArrayList;
/*
 * 集合的嵌套遍历
 * 需求：
 *  我们班有学生，每一个学生是不是一个对象。所以我们可以使用一个集合表示我们班级的学生。ArrayList<Student>
 *  但是呢，我们旁边是不是还有班级，每个班级是不是也是一个ArrayList<Student>。
 *  而我现在有多个ArrayList<Student>。也要用集合存储，怎么办呢?
 *  就是这个样子的：ArrayList<ArrayList<Student>>
 */
public class ArrayListDemo {
 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("诸葛亮", 30);
 Student s22 = new Student("司马懿", 28);
 Student s33 = new Student("周瑜", 26);
 // 学生进班
 secondArrayList.add(s11);
 secondArrayList.add(s22);
 secondArrayList.add(s33);
 // 把第二个班级存储到学生系统中
 bigArrayList.add(secondArrayList);
 // 创建第三个班级的学生集合
 ArrayList<Student> thirdArrayList = new ArrayList<Student>();
 // 创建学生
 Student s111 = new Student("宋江", 40);
 Student s222 = new Student("吴用", 35);
 Student s333 = new Student("高俅", 30);
 Student s444 = new Student("李师师", 22);
 // 学生进班
 thirdArrayList.add(s111);
 thirdArrayList.add(s222);
 thirdArrayList.add(s333);
 thirdArrayList.add(s444);
 // 把第三个班级存储到学生系统中
 bigArrayList.add(thirdArrayList);
 // 遍历集合
 for (ArrayList<Student> array : bigArrayList) {
 for (Student s : array) {
 System.out.println(s.getName() + "---" + s.getAge());
 }
 }
 }
}

package cn.itcast_02;
import java.util.ArrayList;
import java.util.Random;
/*
 * 获取10个1-20之间的随机数，要求不能重复
 * 
 * 用数组实现，但是数组的长度是固定的，长度不好确定。
 * 所以我们使用集合实现。
 * 
 * 分析：
 *  A:创建产生随机数的对象
 *  B:创建一个存储随机数的集合。
 *  C:定义一个统计变量。从0开始。
 *  D:判断统计遍历是否小于10
 *  是:先产生一个随机数，判断该随机数在集合中是否存在。
 *  如果不存在:就添加，统计变量++。
 *  如果存在:就不搭理它。
 *  否：不搭理它
 *  E:遍历集合
 */
public class RandomDemo {
 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;
 //判断该随机数在集合中是否存在。
 if(!array.contains(number)){
 //如果不存在:就添加，统计变量++。
 array.add(number);
 count++;
 }
 }
 //遍历集合
 for(Integer i : array){
 System.out.println(i);
 }
 }
}

package cn.itcast_03;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
/*
 * 键盘录入多个数据，以0结束，要求在控制台输出这多个数据中的最大值
 * 
 * 分析：
 *  A:创建键盘录入数据对象
 *  B:键盘录入多个数据,我们不知道多少个，所以用集合存储
 *  C:以0结束,这个简单，只要键盘录入的数据是0，我就不继续录入数据了
 *  D:把集合转成数组
 *  E:对数组排序
 *  F:获取该数组中的最大索引的值
 */
public class ArrayListDemo {
 public static void main(String[] args) {
 // 创建键盘录入数据对象
 Scanner sc = new Scanner(System.in);
 // 键盘录入多个数据,我们不知道多少个，所以用集合存储
 ArrayList<Integer> array = new ArrayList<Integer>();
 // 以0结束,这个简单，只要键盘录入的数据是0，我就不继续录入数据了
 while (true) {
 System.out.println("请输入数据：");
 int number = sc.nextInt();
 if (number != 0) {
 array.add(number);
 } else {
 break;
 }
 }
 // 把集合转成数组
 // public <T> T[] toArray(T[] a)
 Integer[] i = new Integer[array.size()];
 // Integer[] ii = array.toArray(i);
 array.toArray(i);
 // System.out.println(i);
 // System.out.println(ii);
 // 对数组排序
 // public static void sort(Object[] a)
 Arrays.sort(i);
 // 获取该数组中的最大索引的值
 System.out.println("数组是：" + arrayToString(i) + "最大值是:"
 + i[i.length - 1]);
 }
 public static String arrayToString(Integer[] i) {
 StringBuilder sb = new StringBuilder();
 sb.append("[");
 for (int x = 0; x < i.length; x++) {
 if (x == i.length - 1) {
 sb.append(i[x]);
 } else {
 sb.append(i[x]).append(", ");
 }
 }
 sb.append("]");
 return sb.toString();
 }
}