一、API

1、应用程序编程接口（java Application Programming Interface）—-API的说明文档或者帮助文档

二、枚举

1、由一组固定的常量组成的类型
2、语法：public enum SexEnum {
BOY,GRIL
}
3、 

  1. public enum SexEnum {
  2.     BOY,GRIL
  3. }
  4. public enum StudyEnum {
  5.     L1,L2,L3
  6. }
  7. public class Student {
  8.     public SexEnum sex;
  9.     public StudyEnum study;
  10. }
  11. 测试、、、、
  12.     public static void main(String[] args) {
  13.         Student stu=new Student();
  14.         //类型只能在枚举中定义的两个中选择
  15.         stu.sex=SexEnum.GRIL;
  16.         if(stu.sex==SexEnum.GRIL){
  17.             System.out.println("织布去了");
  18.         }
  19.         if(stu.sex==SexEnum.BOY){
  20.             System.out.println("放牛去了");
  21.         }
  22.         Scanner input=new Scanner(System.in);
  23.         stu.study=StudyEnum.L1;
  24.         if(stu.study==StudyEnum.L1){
  25.             System.out.println("大数据开发工程师");
  27.         }
  28.         if(stu.study==StudyEnum.L2){
  29.             System.out.println("大数据挖掘工程师");
  31.         }
  32.         if(stu.study==StudyEnum.L3){
  33.             System.out.println("大数据架构师");
  35.         }
  37.     }

三、包装类

1、八种基本数据类型
byte、short、int、long、float、double、boolean、char
2、对应的包装类
Byte、Short、Integer、Long、Float、Double、Boolean、Character
3、

  1. /**
  2.      * byte short long int float double boolean char
  3.      * 
  4.      */
  5.     //字节型----整数的基本数据类型的默认值都是0
  6.     byte a1;
  7.     //字节型的包装类，可以直接赋值Byte b1=1,原始的方法如下
  8.     Byte b1=new Byte("123");
  9.     Byte b11;//因为是个对象，没有初始化，默认值是null
  10.     //短整型
  11.     short a2=7;
  12.     Short b2;//默认值是null
  13.     //整型
  14.     int a3=12;
  15.     Integer b3;//默认值是null
  16.     //长整型
  17.     long a4=1000l;//表示1000是long型
  18.     Long b4=a4;//基本数据类型和包装类之间自动转换（装箱和拆箱）
  19.     //单精度浮点数-----小数的基本数据类型的默认值都是0.0
  20.     float a5=0.75f;
  21.     Float b5;//null
  22.     //双精度浮点数
  23.     double a6=8.41d;
  24.     Double b6;//null
  25.     //布尔型-----默认值是fales
  26.     boolean a7=true;
  27.     Boolean b7;//null,对象未被初始化的默认值就是null
  28.     //字符型---默认值是空格' ';
  29.     char a8='a';
  30.     Character b8;//null
  31.     public static void main(String[] args) {
  32.         T1 t1=new T1();
  33.         System.out.println(t1.b8);    
  34.     }

4、字符串，包装类，基本数据类型之间的转换
QQ图片20210310112500.png

  1. public static void main(String[] args) {
  2.         //创建了一个Integer对象，并且赋值为3；
  3.         Integer inte1=new Integer(3);
  4.         //创建了一个Integer对象,将字符串3转化为数字3并赋值
  5.         //在转换过程中，如果转换失败，会抛出数字转换异常NumberFormatException
  6.         Integer inte2=new Integer("3");
  7.         //boolean的构造方法中，如果参数中填入true（不分大小写）
  8.         //，结果均为true，否则为false
  9.         Boolean b=new Boolean("True");
  11.         //1、将int型和integer型进行类型转换；
  12.         int a1=5;
  13.         //(1)、通过构造方法进行类型转换
  14.         Integer b1=new Integer(a1);
  15.         //（2）、自动转换
  16.         b1=a1;
  17.         //2、将integer型转成int型
  18.         a1=b1;
  19.         //3.基本数据类型和包装类型转String类型
  20.         String s1=a1+" ";
  21.         Integer i1=5;
  22.         String s2=i1+" ";
  23.         s2=String.valueOf(i1);
  24.         //4.String类转包装和基本数据类型
  25.         String s3="5";
  26.         Integer i2=Integer.parseInt(s3);
  27.         int a2=Integer.parseInt(s3);
  31.     }

5、//泛型中不可以放基本数据类型。需要使用包装类代替
Listlist=new ArrayList();

四、Math类

1、求绝对值。Math.abs();
int a=Math.abs(-5);
System.out.println(a);
2、最大值和最小值
double b=Math.max(11.3, -2.4); int c=Math.min(5, 8);
System.out.println(b); System.out.println(c);
3、随机数：(大数-小数+1)+小数
0-9： int a=(int)(Math.random()10);
1-10：int a=(int)(Math.random()10+1);
3-8：int a=(int)(Math,random()(8-3+1)+3)
Math.floor((Math.random()*(Max-Min+1))+Min)

Random rand=new Random();
for(){
0-9: int num=rand.nextIn(10);
5-8: int random1=r.nextInt(8-5+1)+5;
}
4、伪随机数

  1. //3是种子，（参照种子生成的随机数） 伪随机数
  2.         Random r1=new Random(3);
  3.         Random r2=new Random(3);
  4.         for (int i = 0; i < 10; i++) {
  5.             int random1=r1.nextInt(10);
  6.             int random2=r2.nextInt(10);
  7.             System.out.println(random1+"----"+random2);
  8.         }
  9.         System.out.println("----------------");
  10.         RandomTest rt=new RandomTest();
  11.         for (int i = 0; i < 10; i++) {
  12.             System.out.println(rt.myRandom());
  13.         }
  16.     }
  17.     public int myRandom(){
  18.         return (int)(System.nanoTime()%10);
  19.     }
  20. }

五、String类

1、==比较的是值；equals()比较的是内存地址；只要是new出来的对象，就会重新创建一个地址，虽然值相等，但是内存地址不同也是false；

  1. public static void main(String[] args) {
  2.         String s1="abc";//JVM帮助创建的对象，手动赋值abc
  3.         String s2=new String();//空串(有内存地址无内容)；null(没有内存地址无内容)
  4.         String s3=new String("abc");//创建String对象并且赋值为abc
  5.         System.out.println("比较值："+s1.equals(s3));//比较值
  6.         System.out.println("比较值："+(s1==s3));//比较地址---false
  7.         //
  8.         String s4="abc";//JVM帮助创建的对象，
  9.         //会先检测有没有已经创建好的值为abc的对象；
  10.         //如果有，直接指向该对象，所以比较地址是一样的
  11.         System.out.println("比较值2："+(s1==s4));//----true
  13.         //new 出的对象每次都会开辟新的内存空间地址
  14.         String s5=new String("abc");
  15.         System.out.println("比较地址3："+(s3==s5));//---false
  17.         //JVM发现拼接字符串，会用拼接后的值进行比较，如果存在该值则指向该内存地址
  18.         String s6="a"+"bc";
  19.         System.out.println("比较地址4："+(s1==s6));//---true
  20.     }

2、pwd.length()字符串长度
.equals(name)比较两次输入的名字是否一致
3、//equalsIgnoreCase()忽略大小写比较
//toLowerCase()转成小写字母,如果后面跟着123，转不了就直接显示，不会报错
//toUpperCase()转成大写字母

  1. public static void main(String[] args) {
  2.         String s1="abc";
  3.         String s2="AbC";
  4.         System.out.println(s1.equals(s2));//比较值---false
  5.         //equalsIgnoreCase()忽略大小写比较
  6.         System.out.println(s1.equalsIgnoreCase(s2));//不区分大小写---true
  7.         //toLowerCase()转成小写字母,如果后面跟着123，转不了就直接显示，不会报错
  8.         System.out.println(s2.toLowerCase());
  9.         //toUpperCase()转成大写字母
  10.         System.out.println(s1.toUpperCase());
  12.     }

4、concat( ），等同于+号，拼接字符串

  1. public static void main(String[] args) {
  2.         String a="ab";
  3.         String b="cd";
  4.         String c=a.concat(b);//a+b
  5.         System.out.println(c);
  6.     }

、字符串常用方法

image.png
image.png

  1. public static void main(String[] args) {
  2.         String s1="abcdefg";
  3.         System.out.println(s1.indexOf("c"));//返回下标2
  4.         System.out.println(s1.indexOf("y"));//没找到返回-1
  5.         System.out.println(s1.indexOf("bc"));//返回1，返回第一个字母出现的位置
  6.         System.out.println(s1.indexOf("bd"));
  7.         System.out.println(s1.indexOf(4));//4是asc码。返回-1；一般使用参数是字符串的
  9.         System.out.println("---------lastIndexOf---------");
  10.         String s2="abcabc";
  11.         System.out.println(s2.lastIndexOf("b"));//4
  12.         System.out.println(s2.indexOf("b"));//1
  14.         System.out.println("---------subString----------");
  15.         String s3="abcabcab";
  16.         System.out.println(s3.substring(2));//cabcab,从下标2开始从前往后截
  17.         System.out.println(s3.substring(2, 4));//ca,>=2&&<4
  19.         System.out.println("-----------trim------------");
  20.         String s4="  ab cd  ";
  21.         System.out.println(s4.trim());//清空（删除）前后的所有空格
  23.         System.out.println("-----------replaceAll-------");
  24.         //将所有空格换成空（清空所有空格）
  25.         System.out.println(s4.replaceAll(" ", ""));
  26.         //axcaxcax将字符b替换成x
  27.         System.out.println(s3.replaceAll("b", "x"));
  28.         System.out.println(s3.replaceAll("ab", "x"));
  29.         System.out.println("-----------replaceFirst-------");
  30.         //只替换第一个出现的匹配字符
  31.         System.out.println(s3.replaceFirst("ab", "x"));
  32.         System.out.println("-----------tocharArray-------");
  33.         String s5="abcd";
  34.         //将字符串转换为char类型的数组
  35.         char[] sArr=s5.toCharArray();
  36. //        System.out.println(sArr[2]);//c
  37.         for (int i = 0; i < sArr.length; i++) {
  38.             System.out.println(sArr[i]);
  39.         }
  41.         String s6="ab cd ef";
  42.         //按照特定规则分割成字符串存储到数组
  43.         String[] sArr2=s6.split(" ");
  44.         for (int i = 0; i < sArr2.length; i++) {
  45.             System.out.println(sArr2[i]);
  46.         }

接下来是练习

1、length（）和equals（）

  1. public static void main(String[] args) {
  2.         Scanner input=new Scanner(System.in);
  3.         while(true){
  4.             System.out.println("请输入用户名：");
  5.             String name=input.next();
  6.             System.out.println("请输入密码：");
  7.             String pwd1=input.next();
  8.             System.out.println("请再次输入密码：");
  9.             String pwd2=input.next();
  10.             if(name.length()>=3&&pwd1.length()>=6){
  11.                 if(pwd1.equals(pwd2)){
  12.                     System.out.println("注册成功");
  13.                     break;
  14.                 }else{
  15.                     System.out.println("两次密码不相同");
  16.                 }
  17.             }else{
  18.                 System.out.println("用户名长度不能小于3，密码长度不能小于6");
  19.             }
  21.         } 
  24.     }

2、concat（）拼接字符串

  1. public static void main(String[] args) {
  2.         String a="ab";
  3.         String b="cd";
  4.         String c=a.concat(b);//a+b
  5.         System.out.println(c);
  8.     }

3、indexOf（）寻找字符所在位置

  1. String s1="abcdefg";
  2.         System.out.println(s1.indexOf("c"));//返回下标2
  3.         System.out.println(s1.indexOf("y"));//没找到返回-1
  4.         System.out.println(s1.indexOf("bc"));//返回1，返回第一个字母出现的位置
  5.         System.out.println(s1.indexOf("bd"));
  6.         System.out.println(s1.indexOf(4));//4是asc码。返回-1；一般使用参数是字符串的

4、lastIndexOf（）找最后一个元素的下标

  1. System.out.println("---------lastIndexOf---------");
  2.         String s2="abcabc";
  3.         System.out.println(s2.lastIndexOf("b"));//4
  4.         System.out.println(s2.indexOf("b"));//1

5、subString（）

一个参数，是指从指定位置向后截取
两个参数，是指从第一个参数位置，包括该位置元素，截取到第二个参数位置，不包括第二位置元素

  1. System.out.println("---------subString----------");
  2.         String s3="abcabcab";
  3.         System.out.println(s3.substring(2));//cabcab,从下标2开始从前往后截
  4.         System.out.println(s3.substring(2, 4));//ca,>=2&&<4

6、trim（）清空前后所有空格

  1. System.out.println("-----------trim------------");
  2.         String s4="  ab cd  ";
  3.         System.out.println(s4.trim());//清空（删除）前后的所有空格

7、replaceAll（””,””）将前面参数全部转为后面的参数

  1. System.out.println("-----------replaceAll-------");
  2.         //将所有空格换成空（清空所有空格）
  3.         System.out.println(s4.replaceAll(" ", ""));
  4.         //axcaxcax将字符b替换成x
  5.         System.out.println(s3.replaceAll("b", "x"));
  6.         System.out.println(s3.replaceAll("ab", "x"));

8、replaceFirst（）只替换第一个出现的匹配字符

  1. System.out.println("-----------replaceFirst-------");
  2.         //只替换第一个出现的匹配字符
  3.         System.out.println(s3.replaceFirst("ab", "x"));
  4.         System.out.println("-----------tocharArray-------");

9、toCharArray()

//将字符串转换为char类型的数组

  1. System.out.println("-----------tocharArray-------");
  2.         String s5="abcd";
  3.         //将字符串转换为char类型的数组
  4.         char[] sArr=s5.toCharArray();
  5. //        System.out.println(sArr[2]);//c
  6.         for (int i = 0; i < sArr.length; i++) {
  7.             System.out.println(sArr[i]);
  8.         }

10、split(“ “)

按照特定规则分割成字符串存储到数组

  1. String s6="ab cd ef";
  2.         //按照特定规则分割成字符串存储到数组
  3.         String[] sArr2=s6.split(" ");
  4.         for (int i = 0; i < sArr2.length; i++) {
  5.             System.out.println(sArr2[i]);
  6.         }

11、给定字符串查找元素的个数

  1. public static void main(String[] args) {
  2.         //方案一
  3.                 String s="我爱你中国，我爱你故乡！";
  4.                 String key="爱";
  5.                 int count1=0;
  6.                 while(true){
  7.                     int index=s.indexOf(key);
  8.                     if(index>=0){
  9.                         s=s.substring(index+1);
  10.                         count1++;
  11.                     }else{
  12.                         break;
  13.                     }
  14.                 }
  15.                 System.out.println(count1);
  17.         //方案二
  18.         String[] sArr=s.split("爱");
  19.         System.out.println(sArr.length-1);
  22.         //方案三
  23.         Scanner input=new Scanner(System.in);
  24.         System.out.println("请输入一个字符串：");
  25.         String name=input.next();
  26.         System.out.println("请输入要查找的字符：");
  27.         String zf=input.next();
  28.         String copyname=name;//
  29.         String copyname2=copyname.replaceAll("爱", " ");
  30.         char[] array1= name.toCharArray();
  31.         char[] array2= copyname2.toCharArray();
  32.         int count=0;
  33.         for (int i = 0; i < array1.length; i++) {
  34.             if(array1[i]!=array2[i]){
  35.                 count++;
  36.             }
  37.         }
  38.         System.out.println("“"+name+"”"+"中包含"+count+"个"+"“"+zf+"”");
  42.     }

12、歌词一行带空格转为多行

  1. public static void main(String[] args) {
  2.         System.out.println("****原歌词格式******");
  3.         String word="长亭外  古道边  芳草碧连天  晚风扶柳笛声残  夕阳山外山";
  4.         System.out.println(word+"\n");
  5.         System.out.println("****拆分后歌词格式******");
  6.         //方案一,将空格替换为换行
  7.         System.out.println(word.replace("  ", "\n"));
  8.         //方案二
  9.         String[] a=word.split("  ");
  10.         for (int i = 0; i < a.length; i++) {
  11.             System.out.println(a[i]);
  12.         }
  13.     }

13、作业提交系统

  1. public static void main(String[] args) {
  2.         Scanner input=new Scanner(System.in);
  3.         System.out.println("请输入Java文件名：");
  4.         String javaName=input.next();
  5.         //知道最后一个点出现的位置
  6.         int index=javaName.lastIndexOf(".");
  7.         //也可以直接截取点后面的所有，javaName.subString(index);
  8.         if(javaName.substring(index+1, javaName.length()).equals("java")){
  9.             System.out.println("请输入你的邮箱：");
  10.             String email=input.next();
  11.             //email必须含有@和 .;并且@在点之前
  12.             if(email.indexOf("@")>0&&email.indexOf(".")>email.indexOf("@")){
  13.                 System.out.println("提交成功");
  14.             }else{
  15.                 System.out.println("邮箱格式不正确");
  16.             }
  18.         }else{
  19.             System.out.println("文件名错误");
  20.         }
  24.         //邮箱E-mail
  25.         String email1="123abc@qq.com";
  26.         int index1=email1.lastIndexOf("@");
  27.         int index2=email1.lastIndexOf(".");
  28.         if(index1>=0&&index2>0){
  29.             if(index2>index1){
  30.                 System.out.println("正确");
  31.             }
  32.         }
  34.         String word="Hello,  ";
  35.         word=word.trim();
  36.         String s=word.concat("小鱼儿!");
  37.         int index3=s.indexOf(",");
  38.         int index4=s.indexOf("!");
  39.         //输出小鱼儿
  40.         System.out.println(s.substring(index3+1, index4));
  42.     }

14、模拟压缩

  1. /**
  2.      * 模拟压缩
  3.      * aaabbbcdddee-->a3b3cd3e2
  4.      * @param args
  5.      */
  6.     public static void main(String[] args) {
  7.         Scanner input=new Scanner(System.in);
  8.         System.out.println("请输入字符串：");
  9.         String strName=input.next();
  10.         char[] strName1=strName.toCharArray();
  11.         int count=1;
  12.         String result="";
  13.         for (int i = 0; i < strName1.length-1; i++) {
  14.             if(strName1[i]==strName1[i+1]){
  15.                 count++;
  16.             }else{
  17.                 result=result+strName1[i]+count;
  18.                 count=1;
  19.             }
  20.         }
  21.         result=result+strName1[strName1.length-1]+count;
  22.         System.out.println(result);
  24.     }

15、模拟解压

  1. /**
  2.      * 模拟解压
  3.      * a3b3cd3e2-->aaabbbcdddee
  4.      * char型到int型要转换Integer.pas+""
  5.      */
  6.     public static void main(String[] args) {
  7.         Scanner input=new Scanner(System.in);
  8.         System.out.println("请输入压缩字符串：");
  9.         String a=input.next();
  10.         char[] x=a.toCharArray();
  11.         String str="";
  12.         for (int i = 1; i < x.length; i=i+2) {//取数字部分
  13.             for (int j = 0; j < Integer.parseInt(x[i]+""); j++) {//将x[i]转换成int型
  14.                 str=str+x[i-1];
  15.             }
  16.         }
  17.         System.out.println(str);
  18.     }

16、统计字符串数字个数，摘取，排序

  1. /**
  2.      * 统计字符串中的数字个数
  3.      * "abc1d3c4v2v14"==>输出6
  4.      * ===>输出数字，（不重复）134214
  5.      * ===>输出数字（不重复），从小到大按顺序输出
  6.      * @param args
  7.      */
  8.     public static void main(String[] args) {
  9.         String s="abc1d3c4v2v14";
  10.         char[] sArr=s.toCharArray();
  11.         int count=0;
  12.         Set<String> set=new HashSet<String>();
  13.         for (int i = 0; i < sArr.length; i++) {
  14.             if(sArr[i]>'0'&&sArr[i]<'9'){//sArr[i]字符型，而里面数字的asc码只能是0-9
  15.                 count++;
  16.                 set.add(sArr[i]+"");
  18.             }
  20.         }
  21.         System.out.println(count);
  22.         System.out.println("--------------------");
  23.         for (String s1 : set) {
  24.             System.out.println(s1);
  25.         }
  26.         System.out.println("-----------------");
  27.         List<String> list=new ArrayList<String>(set);
  28.         Collections.sort(list);
  29.         for (int i = 0; i < list.size(); i++) {
  30.             System.out.println(list.get(i));
  31.         }
  32.     }

17、逆序输出：i am groot 逆置为：groot am i

  1. /**
  2.      * 逆序输出：i am groot 逆置为：groot am i
  3.      */
  4.     public static void main(String[] args) {
  5.         String s="i am groot";
  6.         String[] sArr=s.split(" ");
  7.         for (int i = sArr.length-1; i >=0 ; i--) {
  8.             if(i!=0){
  9.                 System.out.print(sArr[i]+" ");
  10.             }else{
  11.                 System.out.print(sArr[i]);
  12.             }
  14.         }
  15.         System.out.println("\n"+"---------------");
  16.         char[] sArr1=s.toCharArray();
  17.         for (int i = sArr1.length-1; i >=0 ; i--) {
  18.             System.out.print(sArr1[i]);
  19.         }
  20.     }

18、To be or not to be”，将变成”oT eb ro ton ot eb.”

  1. /**
  2.      * "To be or not to be"，将变成"oT eb ro ton ot eb."。
  3.      */
  4.     public static void main(String[] args) {
  5.         String s="To be or not to be";
  6.         String result="";
  7.         String[] sArr=s.split(" ");
  8.         for (int i = 0; i < sArr.length; i++) {
  9.             String s1=sArr[i];
  10.             char[] cArr=s1.toCharArray();
  11.             result+=" ";
  12.             for (int j =  cArr.length-1; j >=0; j--) {
  13.                 result=result+cArr[j];
  14.             }
  16.         }
  17.         System.out.println(result.replaceFirst(" ", ""));
  18. //        String s1="";
  19. //        char[] sArr=s.toCharArray();
  20. //        for (int i = sArr.length-1; i >=0 ; i--) {
  21. //              s1+=sArr[i]+"";
  22. //        }
  23. //        String[] sArr1=s1.split(" ");
  24. //        for (int i = sArr1.length-1; i >=0 ; i--) {
  25. //            if(i!=0){
  26. //                System.out.print(sArr1[i]+" ");
  27. //            }else{
  28. //                System.out.print(sArr1[i]);
  29. //            }
  30. //            
  31. //        }
  33.     }

19、示例 1 输入: 123 输出: 321

  1. /**
  2.      *  示例 1:
  3.         输入: 123
  4.         输出: 321
  6.         示例 2:
  7.         输入: -123
  8.         输出: -321
  10.         示例 3:
  11.         输入: 120
  12.         输出: 21
  13.      */
  14.     public static void main(String[] args) {
  15.         Scanner input=new Scanner(System.in);
  16.         System.out.println("请输入数字：");
  17.         int num=input.nextInt();
  18.         int a=0;    
  19.         while(num!=0){
  20.             int b=num%10;//取最后一位
  21.             a=a*10+b;
  22.             num=num/10;
  23.         }
  24.         System.out.println(a);
  25.     }

20、给定数组和一个数，寻找数组中2个数的和

4种方法

  1. /**
  2.      * 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
  3.      * 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
  4.      * 给定 nums = [2, 7, 11, 15], target = 9
  5.             因为 nums[0] + nums[1] = 2 + 7 = 9
  6.             所以返回 [0, 1]
  7.      */
  8.     public static void main(String[] args) {
  9.         int[] a={2,7,11,15,3,7,5,15};
  10.         int target=14;
  11.         a:for (int i = 0; i < a.length; i++) {
  12.             for (int j = i+1; j < a.length; j++) {
  13.                 if(a[i]+a[j]==target){
  14.                     System.out.println("["+i+","+j+"]");
  15.                     break a;
  16.                 }
  17.             }
  18.         }
  19.         Test8 t8=new Test8();
  20.         int[] b={2,2,1,5,4,3,7,8};
  21.         int target1=9;
  22.         int[] result=t8.sum1(b, target1);
  23.         for (int i : result) {
  24.             System.out.print(i+",");
  25.         }
  26.     }
  27.     public  int[] sum1(int[] b,int target1){
  28.         int[] result={0,0};
  29.         for (int i = 0; i < b.length; i++) {
  30.             for (int j = i+1; j < b.length; j++) {
  31.                 if(b[i]+b[j]==target1){
  32.                     result[0]=i;
  33.                     result[1]=j;
  34.                     return result;
  35.                 }
  36.             }
  37.         }
  38.         return result;        
  39.     }
  40.     public int[] sum2(int[] a,int target){
  41.         int[] result = {0,0};
  42.         Map<Integer, Integer> map = new HashMap<Integer, Integer>();
  43.         for (int i = 0; i < a.length;i++) {
  44.             map.put(a[i], i);
  45.         }
  46.         for (int i = 0; i < a.length;i++) {
  47.             int res = target - a[i];
  48.             if (map.containsKey(res)) {
  49.                 int j = map.get(res);
  50.                 result[0] = i;
  51.                 result[1] = j;
  52.                 return result;
  53.             }
  54.         }
  55.         return result;
  56.     }
  57.     public int[] sum3(int[] a,int target){
  58.         int[] result={0,0};
  59.         Map<Integer,Integer> map=new HashMap<Integer,Integer>();
  60.         for (int i = 0; i < a.length; i++) {
  61.             int res=target-a[i];
  62.             if(map.containsKey(res)){//找指定的key
  63.                 int j=map.get(res);
  64.                 result[0] = i;
  65.                 result[1] = j;
  66.                 return result;
  67.             }
  68.             map.put(a[i], i);
  69.         }
  70.         return result;
  72.     }

六、StringBuffer和stringBuilder

1、举例说明String和buffer和builder的效率，拼接字符串时效率不同，StringBuilder>StringBuffer>String

  1. /**
  2.      * String StringBuffer StringBuilder三者的区别
  3.      * 1、拼接字符串时效率不同，StringBuilder>StringBuffer>String
  4.      * 
  5.      */
  7.     public static void main(String[] args) {
  8.         //比较String和Stringbuffer的效率
  9.         String s="";
  10.         long start1=System.currentTimeMillis();
  11.         for (int i = 0; i < 20000; i++) {
  12.             s+=i;
  13.         }
  14.         long end1=System.currentTimeMillis();
  15.         System.out.println("String拼接字符串耗时="+(end1-start1));
  16.         System.out.println("=======================");
  18.         long start2=System.currentTimeMillis();
  19.         StringBuffer sbu=new StringBuffer();
  20.         for (int i = 0; i < 20000; i++) {
  21.             //append()追加字符串
  22.             sbu.append(i);
  23.         }
  24.         long end2=System.currentTimeMillis();
  25.         System.out.println("StringBuffer拼接字符串耗时="+(end2-start2));
  26.         System.out.println("==================================");
  27.         long start3=System.currentTimeMillis();
  28.         StringBuilder sbu2=new StringBuilder();
  29.         for (int i = 0; i < 20000; i++) {
  30.             //append()追加字符串
  31.             sbu2.append(i);
  32.         }
  33.         long end3=System.currentTimeMillis();
  34.         System.out.println("StringBuilder拼接字符串耗时="+(end3-start3));
  36.     }

2、三者区别，除了第一点，还有String是不可变对象，每次改变都要生成新的String对象，处理效率慢，如果遇到经常改变内容的字符串最好不要用；StringBuffer和StringBuilder都是可变的字符串，StringBuffer进行改变时，不生成新的对象，所以效率比String高一点，理论上StringBuilder效率会更高，但是StringBuffer类线程是安全的，而StringBuilder是单线程的；

3、append();追加字符串

StringBuilder sbu2=new StringBuilder();
sbu2.append(i);

4、 insert（）

在指定的索引位置前插入数据

5、reverse（）

反转字符串，倒着输出
6、举例

  1. public static void main(String[] args) {
  2.         StringBuffer sbu=new StringBuffer("abc");
  3.         //在指定的索引位置前插入数据
  4.         sbu.insert(1, "Y");
  5.         System.out.println(sbu);
  6.         //reverse()反转字符串，倒着输出
  7.         StringBuffer sb1=sbu.reverse();
  8.         System.out.println(sb1);
  11.     }

7、String StringBuffer相互转换

  1. //StringBuffer-->String
  2.     public String sbuToString(StringBuffer sbu){
  3.         return sbu.toString();
  4.     }
  5.     //String-->StringBuffer
  6.     public StringBuffer stringToSbu(String s){
  7.         return new StringBuffer(s);
  8.     }

8、练习 ，1，000，000，000

  1. public static void main(String[] args) {
  2.         Scanner input=new Scanner (System.in);
  3.         System.out.println("请输入一串数字：");
  4.         String nums=input.next();
  5.         StringBuffer sb=new StringBuffer(nums);
  6.         //从后往前，每隔三个插入一个，号
  7.         for (int i = sb.length()-3; i>0; i-=3) {
  8.             sb.insert(i, ",");
  9.         }
  10.         System.out.println(sb);
  11.         //去掉，号
  12.         String s1=sb.toString();
  13.         String s2=s1.replaceAll(",", "");
  14.         System.out.println(s2);

七、日期操作类

1、当前时间
//当前时间
Date date=new Date();
System.out.println(date);
2、日期格式化
SimpleDateFormat
日期—->字符串

  1. public static void main(String[] args) {
  2.         T4 t4=new T4();
  3.         Date date=new Date();
  4.         String s =t4.dateToString(date);
  5.         System.out.println("当前时间为："+s);
  6.     }
  8.     private String dateToString(Date date) {
  9.         //日期的格式化
  10.                 SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒sss毫秒E");
  11.                 return sdf.format(date);//format(d)日期变成字符串
  12.     }

字符串—->日期

  1. public static void main(String[] args) {
  2.     String s="2021-03-11 15:00:00";
  3.         Date d=null;
  4.         try {
  5.              d=t1.stringToDate(s);
  6.         } catch (ParseException e) {
  8.             e.printStackTrace();
  9.         }
  10.         System.out.println(d);
  11.     }
  12. /*
  13.      * 字符串转日期
  14.      */
  15.     public Date  stringToDate(String s) throws ParseException{
  16.         SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  17.         //解析，手动添加处理异常
  18.         return sdf.parse(s);//parse(s)字符串转日期
  19.     }

3、设置年月日
//如果只设置一个年份，其他月份日子输出时都沿用当时操作的日期值

  1. public static void main(String[] args) {
  2.         Calendar cal=Calendar.getInstance();
  3.         //设置日期，因为是静态常量，所以类名.直接就行
  4.         cal.set(Calendar.YEAR, 2015);
  5.         //月份设置，5显示6月
  6.         cal.set(Calendar.MONTH, 3);
  7.         cal.set(Calendar.DATE, 6);
  8.         cal.set(Calendar.HOUR_OF_DAY, 15);
  9.         cal.set(Calendar.MINUTE, 14);
  10.         cal.set(Calendar.SECOND, 59);
  11.         //设置年份，其他沿用当前时间
  12.         Date d=cal.getTime();
  13.         System.out.println(d);
  14.         SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  15.         System.out.println(sdf.format(d));
  16. }

4、算星期几或者在第几周

  1. public static void main(String[] args) {
  2.     int i=cal.get(Calendar.DAY_OF_WEEK);
  3.         System.out.println(i);//6--->星期五、2-->星期一
  4.         int i1=cal.get(Calendar.WEEK_OF_YEAR);
  5.         System.out.println(i1);//一年中的第几个星期
  6.     }

5、2015-04-06是第几个星期

  1. public static void main(String[] args) {
  2.     String date="2015-04-06";
  3.         Calendar cal=Calendar.getInstance();
  4.         //一周的第一天是周一
  5.         cal.setFirstDayOfWeek(Calendar.MONDAY);
  6.         SimpleDateFormat format=new SimpleDateFormat("yyyy-MM-dd");
  7.         Date d=null;
  8.         try {
  9.             d=format.parse(date);
  10.         } catch (ParseException e) {
  12.             e.printStackTrace();
  13.         }
  14.         cal.setTime(d);
  15.         int week=cal.get(Calendar.WEEK_OF_YEAR);
  16.         System.out.println("2015年4月6号是第"+week+"个星期");
  17.     }