package com.qianfeng.test;
/*
*可变参数:参数的个数可以改变
*作用:简化代码,方便操作。
*/
public class Demo5 {
public static void main(String[] args) {
// 值传递
int he1 = sum(2, 2, 4);
System.out.println(he1);
// 址传递
int[] arr1 = { 3, 4, 5 };
int he2 = sum(arr1);
System.out.println(he2);
//通过可变参数求和
int[] arr2 = { 3, 4, 5 };
int he3 = sum1(arr2);
System.out.println(he3);
//可变参数的注意点:
//1.给可变参数传值的实参可以直接是多个值
int he4 = sum1(3,4,5,6,7,8);
System.out.println(he4);
//2.当包括可变参数在内有多个参数时,可变参数必须放在最后,并且一个方法只能同时有一个可变参数。
int he5 = sum2(3,4,5);
System.out.println(he5);
//3.当固定参数的方法与可变参数的方法是重载时,固定参数方法的优先级高于可变参数。
sum3(3,4);//这里调用的是固定参数的方法。
}
// 求和
public static int sum(int a, int b, int c) {
return a + b + c;
}
public static int sum(int[] a) {
int sum = 0;
for (int i : a) {
sum += i;
}
return sum;
}
// 通过可变参数求和
// 可变参数的构成: 数据类型+... 可变参数可以直接理解成数组 int... = int[]
public static int sum1(int... a) {
int sum = 0;
for (int i : a) {
sum += i;
}
return sum;
}
//当包括可变参数在内有多个参数时,可变参数必须放在最后,并且一个方法只能同时有一个可变参数。
public static int sum2(int b,int... a) {
int sum = 0;
for (int i : a) {
sum += i;
}
return sum;
}
//下面两个方法是重载的关系
//当固定参数的方法与可变参数的方法是重载时,固定参数方法的优先级高于可变参数。
public static int sum3(int b,int... a) {
System.out.println("可变参数");
int sum = 0;
for (int i : a) {
sum += i;
}
return sum;
}
public static int sum3(int a,int b) {
System.out.println("固定参数");
return 0;
}
}
package com.qianfeng.test;
import java.util.Arrays;
import java.util.List;
/*
*Arrays:数组工具类,内部封装了大量操作数组的方法,包括排序,查找,求最大值等。
*/
public class Demo4 {
public static void main(String[] args) {
//1.简单数据类型转换成字符串--方便查看内容
int[] arr1 = new int[]{3,5,8,9,3};
System.out.println(arr1.toString());//[I@2a139a55,默认打印的是数组的地址。
System.out.println(Arrays.toString(arr1));//[3, 5, 8, 9, 3],数组被转换成了字符串。
//2.数组转集合?----集合的方法多,方便查看内容。
//简单数组类型转集合。
int[] arr2 = new int[]{3,5,8,9,3};
List<int[]> list = Arrays.asList(arr2);
System.out.println(list.size());//1,说明对应简单数据类型的数组,asList方法会将整体当成一个元素扔到集合中。
//引用数据类型转集合
String[] strings = {"a","b","c"};
List<String> list2 = Arrays.asList(strings);
System.out.println(list2.size());//3,说明对于引用数据类型的数组,asList方法会将数组的一个元素作为集合的一个元素。
//数组转集合的注意点:
//转成的集合的元素个数是固定的,所以不能进行添加和删除,但能进行修改和遍历。
//list2.add("java");//运行报异常UnsupportedOperationException
list2.set(0, "d");
System.out.println(list2);
//二分查找--数组必须是有序的
int[] arr3 ={2,4,6,8,90};
int index = Arrays.binarySearch(arr3, 98);//-6 负数说明未找到,6是98该有的下标。
System.out.println(index);
}
}
package com.qianfeng.test;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
/*
*Collections:集合工具类,封装了大量操作集合的方法。
*
*实例:要求存储多个数据,数据可以排序,也可以重复。
*/
public class Demo6 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("java");
list.add("html");
list.add("python");
list.add("iOS");
list.add("iOS");
list.add("BigData");
// 自然顺序
System.out.println("自然顺序" + list);
// 字典顺序--默认都是升序
// 这里要想实现排序,要求元素必须实现Comparable接口的compareTo方法
Collections.sort(list);
System.out.println("字典排序" + list);
// 按照从短到长排序--默认的方法无法实现,创造自己的比较器
ComWithLength comWithLength = new ComWithLength();
Collections.sort(list, comWithLength);
System.out.println("从短到长排序" + list);
// 按照从长到短排序--利用现有的从短到长的比较器得到新的比较器对象-从长到短
Comparator<String> comparator1 = Collections.reverseOrder(comWithLength);
Collections.sort(list, comparator1);
System.out.println("从长到短排序" + list);
// 字典顺序的倒序
Comparator<String> comparator2 = Collections.reverseOrder();
Collections.sort(list, comparator2);
System.out.println("字典顺序的倒序" + list);
// 现有顺序的倒序
Collections.reverse(list);
System.out.println("现有顺序的倒序" + list);
//求最大值
String max1 = Collections.max(list);
System.out.println("默认的字典顺序的最大值:"+max1);
String max2 = Collections.max(list,comWithLength);
System.out.println("从短到长排序的最大值:"+max2);
}
}
// 创造自己的比较器–字符串从短到长
class ComWithLength implements Comparator {
@Override
public int compare(String o1, String o2) {
int num = o1.length() - o2.length();
return num == 0 ? o1.compareTo(o2) : num;
}
}