1. 可变参数
在JDK1.5之后，如果我们定义一个方法需要接受多个参数，并且多个参数类型一致，我们可以对其简化.
格式：
修饰符 返回值类型 方法名(参数类型... 形参名){ }
底层：
其实就是一个数组
好处：
在传递数据的时候，省的我们自己创建数组并添加元素了，JDK底层帮我们自动创建数组并添加元素了
package ChangeArgs;
public class demo1 {
public static void main(String[] args) {
int sum = getSum(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
System.out.println(sum);
}
public static int getSum(int... args) {
int sum = 0;
for (int i : args) {
sum += i;
}
return sum;
}
}
注意：
1.一个方法只能有一个可变参数
2.如果方法中有多个参数，可变参数要放到最后。
如下
2. Collections类
2.1 Collections常用功能
java.utils.Collections是集合工具类，用来对集合进行操作。常用方法如下：
public static void shuffle(List<?> list):打乱集合顺序。
public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。
public static <T> void sort(List<T> list，Comparator<? super T> ):将集合中元素按照指定规则排序。
代码演示：
public class demo1 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
//把这些元素添加在list集合里
Collections.addAll(list, "abc", "bba", "ccd", "gge");
System.out.println(list);
//随机打乱顺序
Collections.shuffle(list);
System.out.println(list);
//将集合中元素按照默认规则排序。
Collections.sort(list);
System.out.println(list);
}
我们的集合按照默认的自然顺序进行了排列，如果想要指定顺序那该怎么办呢？
2.2 Comparator比较器
创建一个学生类，存储到ArrayList集合中完成指定排序操作。
Student 类
public class Student{
private String name;
private int age;
//构造方法
//get/set
//toString
}
测试类：
package mycollections;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class demo2 {
public static void main(String[] args) {
Student s1=new Student("zhangsan",17);
Student s2=new Student("lisi",16);
Student s3=new Student("wangwu",18);
ArrayList<Student> list=new ArrayList<Student>();
list.add(s1);
list.add(s2);
list.add(s3);
Collections.sort(list, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
//以学生的年龄升序
int age=o1.getAge()-o2.getAge();
return age;
}
});
for (Student student : list) {
System.out.println(student);
}
}
}
3. 综合练习
练习1：随机点名器
需求：班级里有N个学生，实现随机点名器
package lx;
import java.util.ArrayList;
import java.util.Collections;
/*练习1：随机点名器
需求：班级里有N个学生，实现随机点名器
*/
public class demo1 {
public static void main(String[] args) {
//1.定义集合
ArrayList<String> list = new ArrayList<String>();
//2.添加数据
Collections.addAll(list,"范闲","范建","范统","杜子腾","杜琦燕","宋合泛","侯笼藤","朱益群","朱穆朗玛峰");
//3.随机打乱
Collections.shuffle(list);
System.out.println(list);
}
}
练习2：带概率的随机
需求：
班级里有N个学生
要求在随机的时候，70%的概率随机到男生，30%的概率随机到女生
package lx;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;
/* 班级里有N个学生
要求：
70%的概率随机到男生
30%的概率随机到女生
"范闲","范建","范统","杜子腾","宋合泛","侯笼藤","朱益群","朱穆朗玛峰",
"杜琦燕","袁明媛","李猜","田蜜蜜",
*/
public class demo2 {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
//添加数据
Collections.addAll(list, 1, 1, 1, 1, 1, 1, 1);
Collections.addAll(list, 0, 0, 0);
//打乱集合顺序
Collections.shuffle(list);
//随机在集合里抽取一个数,通过这个数是0还是1判断男女
Random r = new Random();
int index = r.nextInt(list.size());
int number = list.get(index);
//创建一个存储男生名字的集合
ArrayList<String> Boys = new ArrayList<>();
Collections.addAll(Boys, "范闲", "范建", "范统", "杜子腾", "宋合泛", "侯笼藤", "朱益群", "朱穆朗玛峰");
//创建一个存储女生名字的集合
ArrayList<String> Girls = new ArrayList<>();
Collections.addAll(Girls, "杜琦燕", "袁明媛", "李猜", "田蜜蜜");
//根据number来随机男生还是女生里面集合的数据
if (number == 1) {
int boyIndex = r.nextInt(Boys.size());
System.out.println(Boys.get(boyIndex));
} else {
int girIndex = r.nextInt(Girls.size());
System.out.println(Girls.get(girIndex));
}
}
}
练习3：随机不重复
需求：
班级里有N个学生，被点到的学生不会再被点到。但是如果班级中所有的学生都点完了， 需要重新开启第二轮点名。
package lx;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
public class demo3 {
public static void main(String[] args) {
/* 班级里有5个学生
要求：
被点到的学生不会再被点到。
但是如果班级中所有的学生都点完了，需要重新开启第二轮点名。*/
//1.定义集合
ArrayList<String> list1 = new ArrayList<>();
//2.添加数据
Collections.addAll(list1, "范闲", "范建", "范统", "杜子腾", "杜琦燕", "宋合泛", "侯笼藤", "朱益群", "朱穆朗玛峰", "袁明媛");
//创建一个临时的集合，用来存已经被点到学生的名字
ArrayList<String> list2 = new ArrayList<>();
for (int j = 1; j <= 10; j++) {
Collections.shuffle(list1);
Iterator<String> it = list1.iterator();
System.out.println("=========第" + j + "轮点名开始了======================");
while (it.hasNext()) {//当前迭代器对象指向地方是否有元素,默认指向0索引
String s = it.next();//获取当前迭代器对象指向的元素,并且指针+1
System.out.println(s);
it.remove();//从迭代器指向的 collection 中移除迭代器返回的最后一个元素
//说白了就是迭代器指向的前一个元素
list2.add(s);
}
//此时表示一轮点名结束
//list1 空了 list2 10个学生的名字
list1.addAll(list2);
list2.clear();
}
}
}
练习4：集合的嵌套
需求：
定义一个Map集合，键用表示省份名称province，值表示市city，但是市会有多个。
添加完毕后，遍历结果格式如下：
江苏省 = 南京市，扬州市，苏州市，无锡市，常州市
湖北省 = 武汉市，孝感市，十堰市，宜昌市，鄂州市 河北省 = 石家庄市，唐山市，邢台市，保定市，张家口市代码实现：
package lx;
import java.util.*;
/*
需求：
定义一个Map集合，键用表示省份名称province，值表示市city，但是市会有多个。
添加完毕后，遍历结果格式如下：
江苏省 = 南京市，扬州市，苏州市，无锡市，常州市
湖北省 = 武汉市，孝感市，十堰市，宜昌市，鄂州市
河北省 = 石家庄市，唐山市，邢台市，保定市，张家口市
*/
public class demo4 {
public static void main(String[] args) {
HashMap<String, ArrayList<String>> hm = new HashMap<>();
//创建单列集合(值的)
ArrayList<String> list1 = new ArrayList<>();
Collections.addAll(list1, "南京市，扬州市，苏州市，无锡市，常州市");
ArrayList<String> list2 = new ArrayList<>();
Collections.addAll(list2, "武汉市，孝感市，十堰市，宜昌市，鄂州市");
ArrayList<String> list3 = new ArrayList<>();
Collections.addAll(list3, "石家庄市，唐山市，邢台市，保定市，张家口市");
hm.put("江苏省", list1);
hm.put("湖北省", list2);
hm.put("河北省", list3);
//把所有的键值对对象存入一个Set集合里面
Set<Map.Entry<String, ArrayList<String>>> entries = hm.entrySet();
//循环遍历每一个键值对对象,得到每一个键值对对象
for (Map.Entry<String, ArrayList<String>> entry : entries) {
//entry依次表示每一个键值对对象
//通过每一个键值对象获取每一个键和值
String key = entry.getKey();
//因为值是一个单列集合,我们通过增强for去得到每一个键
ArrayList<String> value = entry.getValue();
for (String s : value) {
System.out.println(key + "=" + s);
}
}
}
}
