import java.util.*;
/*
* TreeMap使用的注意点：
* 1.什么类型的数据类型可以作为key?
* a实现了Comparable接口的CompareTo()方法
* b实现了Comparator接口的Compare()方法
*
* JAVA的三种引用引用类型：类，接口，数组。
* 其中类和数组的父类都是Object(问了老师，数组的父类是Object)
* 而Object类没有做a,b处理
* TreeMap添加键时调用的put方法会去检测是否做了a,b中的任何一个处理，没有会有运行时异常
* 可以的代表:String 包装类,自定义的实现了这两个接口重写了相应方法的任意一个的类
* 不可以的代表:没有做a,b处理的自定义类，数组，ArrayList和LinkedList
*
*
* 疑问：为什么HashMap就任何引用类型都可以作为key?
* JAVA的三种引用引用类型：类，接口，数组。
* 其中类和数组的父类都是Object(问了老师，数组的父类是Object)
* 接口是没有父类的
* Object类中里有equals()方法和hashCode()方法的声明及方法体
* 所以在HashMap里存对象和数组是没有问题的
*
* 2.元素可不可以作为key,跟元素内部的元素类型有没有关系
*/
class A{}
public class Demo1 {
public static void main(String[] args)
{
TreeMap <char[],String> map=new TreeMap<>();
map.put(new char[] {'d'}, "String");
//在调用put方法的时候会报运行时异常，数组内部没有实现那两个接口
TreeMap<A,Integer> map1=new TreeMap<>();
map1.put(new A(),1);
//在调用put方法的时候会报运行时异常，类A内部没有实现那两个接
//2.元素可不可以作为key,跟元素内部的元素类型有没有关系
TreeMap<Test,String> tree=new TreeMap() ;
tree.put(new Test(), "ok");
System.out.println(tree);
}
}
class Test implements Comparable{
Object object = new Object();
@Override
public int compareTo(Object o) {
return 0;
}
}
import java.util.*;
public class Demo3 {
public static void main(String[] args) {
/*
* 增强for循环
* 可以遍历的内容：
* 数组,Collction---直接遍历
* Map---间接遍历
*/
/*
* 1遍历数组,Collction:
* for(元素的数据类型 变量:数组/Collection)
* {
* 循环体
* }
*/
//遍历数组
/*
* 原理:当执行增强for循环时，会从数组中自动按顺序取值，取出的值放入前面的变量中，
* 本次循环使用的就是当前的变量
* 结束后，自动开始第二个变量，会自动从数组中取出第二个变量，再次放入
* 前面的变量中一次进行下去，直到将数组中的元素取完为止
* 总结：增强for循环会自动生成数组中的每一项将它赋值给指定元素，从而达到遍历的作用
*/
int[] arr=new int[] {4,5,7,8,8};
for(int i:arr){
System.out.println(i);
}
//对Collection实现类的遍历
ArrayList<String> list=new ArrayList<>();
list.add("java2");
list.add("java3");
for(String str:list)
System.out.println(str);
//对Map的遍历
Map<String,String> map=new HashMap<>();
map.put("01","java");
map.put("04","java3");
map.put("06","java7");
System.out.println(map);
//得到set
Set<String> set=map.keySet();
//使用增强for循环遍历
for(String key:set) {
System.out.println(key+" "+map.get(key));
}
}
}
import java.util.Arrays;
import java.util.List;
public class Demo4 {
public static void main(String[] args) {
/*
* Arrays:数组工具类，内部封装了大量操作数组的方法--工具类的方法都是静态的
*/
//简单数组类型转字符串
int[] arr1= {23,4,6,7,8};
System.out.println(arr1.toString());//[I@7852e922
//打印的hash码，哈希码通常也成为地址
//因为这个值唯一，但是它其实并不是真正的物理地址
//打印出hash码值说明数组并没有重写toString方法
//简单数组类型转字符串---方便查看数组的内容
//内部其实是遍历了这个数组，拼接成字符串
String s1=Arrays.toString(arr1);
System.out.println(s1);//[23, 4, 6, 7, 8]
//数组转集合？---集合的方法多，方便操作
//基本数据类型的数组转集合
int[] arr2={23,4,6,7,8};
List<int[]> list=Arrays.asList(arr2);
//返回一个List集合，集合的泛型为int[]，也就是说该List数组的元素是整型的数组
System.out.println(list);[[I@4e25154f]
System.out.println(list.size());//1
//该集合中只有一个整形数组元素
//引用类型的数组转集合
String[] strs= {"haha","java","xiake"};
List<String> list2=Arrays.asList(strs);
//此时List泛型的类型为String,也就是集合里的元素是String
System.out.println(list2);//此时数组与集合的元素一一对应 //[haha, java, xiake]
System.out.println(list2.size());//3
//注意点：转过来的集合，内存空间是固定的，即长度不能变，所以不能进行增删元素
//但是可以修改，遍历
//list2.add("hehe");运行时异常
for(String s:list2) {
System.out.println(s);
}
//二分查找
int[] arr3= {3,9,7,8,1};
Arrays.sort(arr3);//二分查找的前提是数组有序，所以要先对数组排序
System.out.println(Arrays.toString(arr3));//[1, 3, 7, 8, 9]
int i=Arrays.binarySearch(arr3, 1);//找得到返回>=0，负数表示找不到,这里并不是简单的找不到返回-1，而是任意的复数
System.out.println(i);
}
}
public class Demo5 {
//可变参数
//作用：简化代码，方便能操作
//求三个数的和--值传递
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=0;i<=a.length-1;i++)
sum=sum+a[i];
return sum;
}
//通过可变参数求和
//可变参数的格式：数据类型...
//可变参数可以直接理解成一个数组
//int... 等价于int[]
//public static int sum(int... a)系统认为这是和上面的sum名字相同，参数表相同的方法，会编译异常
public static int sum1(int... a)
{
int sum=0;
for(int i=0;i<=a.length-1;i++)
sum=sum+a[i];
return sum;
}
//public static int sum2(int... a,int b)编译异常，因为会把传的参数都存到a里
public static int sum2(int b,int... a)//
{
int sum=0;
for(int i=0;i<=a.length-1;i++)
sum=sum+a[i];
return sum;
}
//-------------这两个sum3是重载方法-------------
public static int sum3(int a ,int b)
{
System.out.println("不可变");
return a+b;
}
//当可变参数的方法与不可变参数的方法是重载关系时，调用的顺序是固定参数的优先于可变参数的
public static int sum3(int...a)
{
System.out.println("可变");
int sum=0;
for(int i=0;i<=a.length-1;i++)
sum=sum+a[i];
return sum;
}
public static void main(String[] args) {
//可变参数：参数的个数可以改变
//求和1:
System.out.println(sum(9,8,2));
int[] arr1= {3,5,7,9};
sum(arr1);
int[] arr2= {3,5,7,9};
sum1(arr2);
//注意点：
//1.给这个可变参数传值的实参可以直接写且个数不限制
sum1(35,7,8);//系统自动把数封装到一个数组，把数组作为一个参数传给方法
//2.当包括可变参数在内有多个参数时，可变参数必须写在参数表的最后，并且一个方法只能有一个可变参数
System.out.println(sum3(3,4));
}
}
import java.util.*;
/*
* Collections：操作类，内部封装了大量的操作Collections的方法
*/
public class Demo6 {
public static void main(String[] args) {
//要求：存储多个数据，可重复，能排序
//可以想到的集合：
//1.ArrayList，LinkedList:可重复，不能排序（它的有序只是和添加顺序相同）
//2.TreeSet:不可重复，能排序
//这两个都不符合我们的要求
//这里使用ArrayList实现可重复，能排序
//即要想实现排序，元素必须实现了Comparable接口的comapreTo()方法
//或Comparator接口的compare()方法
ArrayList<String> list=new ArrayList<>();
list.add("java");
list.add("ios");
list.add("html");
list.add("html");
list.add("BigData");
list.add("python");
list.add("javascripts");
System.out.println("默认的顺序:"+list);//默认顺序
//升序排序
Collections.sort(list);//String方法已经实现了comapreTo()
//所以这里直接用就行了
System.out.println("升序排序:"+list);
//按照长短排序
//实现从短到长排序---让元素(String),实现Comparator接口
//创建比较器对象
ComWithLength comWithLength=new ComWithLength();
Collections.sort(list,comWithLength);//第二个参数为List内元素的比较器
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<String>{
public int compare(String o1,String o2) {
int num=o1.length()-o2.length();
return num;
}
}
