一、API文档

1.JDK API

什么是JDK API?

  • Application Programming Interface 应用程序接口

  • 已经写好的，可供直接调用的类。

  • 比如: 字符串操作、IO流、集合操作、线程、网络编程Socket等等

API 常用包

常用包                            主要功能

java.lang                   Java程序基础类，如:String、线程Thread等，不用通过import关键字导包

java.util                     工具类，如集合Collection、随机数Random、时间Date等

java.io                       输入输出IO流

java.math                  数学运算操作

java.net                     网络编程，如Socket

java.sql                     操作数据库，如:JDBC

java.text                    文本操作等 JDK常用包 API官方文档 不认识的类就去查

2.文档注释规范

文档注释一般加载类和方法的开头，用于说明作者、时间、版本等信息。 以 “/**”开头

/**
* zhe shi yi ge zi ding yi de Person lei
*
* @author Le
* @since jdk2.1
*/
public class MyPerson {
String name;
int age;
double salary;
/**
* @return int
* @param i
*/
public int show(int i) {
System.out.println("show...");
return i;

文档注释可以使用javadoc命名生成一个html文档
生成结果如下
二、常用类
1.String类
1.1 String对象不能改变
String 的底层是字符数组
String类是final修饰的，不能被继承，不能改变，但引用可以重新赋值
String采用编码方式是Unicode
}
}
 

二、常用类
 

一、String类
 

1.String对象不能改变
 

     String的底层是字符数组
 

private final char value[];//定义了一个字符数组
 

     String类是final修饰的，不能被继承，不能改变，但引用可以重新赋值
 

     String采用编码方式是Unicode
 

2.String常量池
 

  •  
    享元模式:（英语：Flyweight Pattern）是一种软件设计模式。它使用共享物件，用来尽可能减少 内存使用量以及分享资讯给尽可能多的相似物件；它适合用于只是因重复而导致使用无法令人接受 的大量内存的大量物件。通常物件中的部分状态是可以分享。常见做法是把它们放在外部数据结构 （常量池），当需要使用时再将它们传递给享元(字符串的直接量)。
     
  •  
    Java为了提高性能，静态字符串在常量池中创建，并且是同一对象，使用时直接拿取。
     
  •  
    对于重复的字符串直接量，JVM会去常量池查找，如果有则返回，无则创建。
     
 

注意：
 

/*常量池，外部的数据结构，用来存储字符串 --当创建字符串时会去常量池中去查找，如果有对象的对象则直接返回，如果没有则创建
 

  面试加分：
           常量池存储在什么地方？堆中？栈中？方法区中？
           1.jdk1.6，常量池放在方法区的永久代里
           2.jdk1.7，Oracle的工程师调整至java堆中
           3.jdk1.8，移除到Metaspace（元数据区），在堆中
           4.jdk1.8之前，常量池本质是char[]
           5.jdk1.9时，常量池修改为byte类型的数组
 

    
 

测试:常量池
 

//在常量池中查找，没有创建一个"Hello"；
String s = "Hello";
//在常量池中查询，不会创建新对象
String s1 = "Hello";
System.out.println(s == s1);//true
String s2 = new String("Hello");
System.out.println(s1 == s2);//false
 

扩展：
 

扩展案例：
String s = new String("java");创建了几个对象？1/2
  //以下语句分别创建了几个对象？
        String string1 = "java";// 对象：0/1
        //2.
        String string2 = new String("c");//对象：1/2
        //3.常量的拼接在编译时会直接拼接 “java"+”c"---->"javac"
        String string3 = new String("java"+"c");//对象：1/2
​
        //4.
        String str1 = "php"; //
        String string4 = "java" + str1;// 对象：0/1/2/3
        //5."c++" "javaC" "javacc++"
        String str2 = "c++";// 对象：0/1
        String string5 = new String("java" +"c" + str2);// 对象：1/2/3/4
​
        //6."c#" "java"  "c" javac#" "javac#c"
        String str3 = "c#";// 对象：1
​
        String string6 = new String("java" + str3 +"c");// 对象：1/2/3/4/5/6
 

3.构造方法
 

 

 

//1.无参的
String s1 = new String();
System.out.println(s1);//不是null 而是空字符
​
//2.byte[]  Unicode编码转化为对应的字符
String s2  = new String(new byte[]{97,98,99});
System.out.println(s2); //a,b,c
​
//3.byte[]  截取字符串，Unicode编码转化为对应的字符
String s3  = new String(new byte[]{97,98,99},1,1);   //截取
System.out.println(s3); //a,b,c
​
//4.byte[]  GBK编码转化为对应的字符  "GBK"支持中文的编码,"utf-8"国际编码 ,"utf8"
String s4  = new String(new byte[]{97,98,99},1,1,"GBK");   //截取
System.out.println(s4); //a,b,c
​
//5.StringBuffer
String s5 = new String(new StringBuffer("hello"));
System.out.println(s5);
​
//6.byte[],字符集
String s6 = new String(new byte[]{97,98,99},"utf-8");
System.out.println(s6);
​
//7.StringBuilder
String s7 = new String(new StringBuilder("world"));
System.out.println(s7);
​
//8.String副本
String s8 = new String(new String("how are you ?"));
System.out.println(s8);
​
//9.char[]
String s9 = new String(new char[]{'a','b','c'});
System.out.println(s9);
​
//10.char[] 加参数
String s10 = new String(new char[]{'a','b','c','d','e'},1,3);
System.out.println(s10);
​
//11.int[]
String s11 = new String(new int[]{65,66,67},1,2);
System.out.println(s11);
​
//12.找出字符串”java",v出现的位置索引，返回int  参数String 'v'
String str = new String("java");
System.out.println(str.indexOf("v"));
​
//13.根据索引找字符串
char c = str.charAt(1);
System.out.println(c);
​
//14.给出一个字符串，找出末尾是不是为com结束
String str1 = new String("javacom");
System.out.println(str1.endsWith("com"));
 

4.常用方法
 

//一.String的判断方法
/*
        boolean equals(Object obj):比较字符串的内容是否相等
        boolean equalsIgnoreCase(String str):比较字符串的内容是否相同，忽略大小写
        boolean startWith(String str):判断字符串是否以指定的str开头
        boolean endwith(String str):判断字符串是否以指定的str开结尾
 */
        String s1 = "hello";
        String s2 = new String("hello");
        System.out.println(s1.equals(s2));   //true
        System.out.println(s1 == s2);//false
​
        String s3 = "HELLO";
        System.out.println(s1.equalsIgnoreCase(s3));  //true
​
        String s4 = "stroor";
        System.out.println(s4.startsWith("str"));  //true
​
        System.out.println(s4.endsWith("str"));  //false
​
        //二.String 的截取
        /*
        int length():获取字符串的长度，其实也就是字符个数
        char charAt(int index):获取指定索引处的字符
        int indexof(String str):获取str在字符串对象中第一次出现的索引
        String substring(int start)：从start开始截取字符串
        String substring(int start,int end):从start开始，到end结束截取字符串，前包后不包
        */
        String str1 = "hello world";
        System.out.println(str1.length());  //11
​
        System.out.println(str1.charAt(7));  //o
​
        System.out.println(str1.indexOf("o"));  //4
​
        String str2 = str1.substring(4);
        System.out.println(str2);   //o world
​
        String str3 = str1.substring(2,8);
        System.out.println(str3);  //llo wo
​
        //三.String 的转换
        /*
        char[] toCharArray():把字符串转换为字符数组
        String toLowerCase():把字符串转换为小写字符串
        String toUpperCase():把字符串转换为大写字符串
         */
        String string1 = "String,char";
        char[] ch =string1.toCharArray();
        System.out.println(ch);    //String,char
​
        String string2 = "HEllo";
        System.out.println(string2.toLowerCase());   //hello
​
        System.out.println(string2.toUpperCase());   //HELLO
​
        //四.String的其他方法
        /*
        String trim():去除字符串两端空格
        String[] split(String str):按照指定符合分割字符串
         */
        String string3 = " blank   ";
        System.out.println(string3.trim());   //blank
​
        String string4 = new String("hello*world*girl");
        String[] a1 = string4.split("\\*");
        System.out.println(Arrays.toString(a1));
 

5.作业
 

：在StringAPI中任意选取5个方法测试，并总结
 

//作业：在StringAPI中任意选取5个方法测试，并总结
/*1.concat(String str)
     功能：将指定字符串联到当前字符串的结尾
     返回值：String
 */
String str1 = "hello";
System.out.println(str1.concat("world"));  //helloworld
​
/*2.indexOf(String str)
     功能：查询指定的字符串是否存在
     参数：字符串
     返回值：存在，字符串的位置，不存在，返回-1
 */
String str2 = "www.baidu.com";
System.out.println(str2.indexOf("com"));  //10
System.out.println(str2.indexOf("xfv"));  //-1
​
/*3.split(String regex)
      功能：分割字符串
      参数：正则表达式,
      返回值：分割后的字符串数组
 */
String str3 = "I like eat bread";
String[] a = str3.split(" ");
System.out.println(Arrays.toString(a));  //[I, like, eat, bread]
/*4.replace(char oldChar, char newChar)
    功能：替换字符串，使用新的字符替换掉当前字符串中出现的所有旧的字符
    参数：oldChar：被替换的字符串，newChar:新的字符串
    返回值：返回一个新的字符串
 */
String str4 = "I like rice,I like bread ";
System.out.println(str4.replace("like","hate")); //I hate rice,I hate bread
​
/*5.substring(int beginIndex, int endIndex)
    功能：截取字符串，从开始位置截取到结束位置，不包含结束位置 （beginIndex——endIndex-1）
    返回值：返回一个新字符串
 */
String str5 = "communication";
System.out.println(str5.substring(2,7));  //2--6为：mmuni
 

6.案例
 

：在控制台任意输入一个网址（www开头，com结尾），然后根据网址截取中间部分
 

public class TestCase {
    //：在控制台任意输入一个网址（www开头，com结尾），然后根据网址截取中间部分
    //比如www.baidu.com的baidu
​
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
​
​
        System.out.println("请输入一个网址（www开头，com结尾）");
        String str1 = scanner.next();
        if (str1.startsWith("www.") && str1.endsWith(".com")) {
            int start = str1.indexOf(".")+1;
            int end = str1.lastIndexOf(".");
            System.out.println(str1.substring(start,end));
        } else {
            System.out.println("输入有误...");
        }
​
    }
}
 

二、Object类
 

1.object
 

  • - java.lang.Object位于java继承关系的顶端。 
  • - Object类是所有类的父类 
  • - Object类的引用可以指向任意对象。
 

Object person = new Person()；
 

2.tostring方法
 

  • toString 方法的运用：
 


Person p  = new Person();
System.out.println(p);
System.out.println(p.toString());

/*return getClass().getName() + "@" + Integer.toHexString(hashCode());
com.hqyj.api.objects.Person@1540e19d
Person向上造型为Object，当Person对象没有指定的值时，返回地址

*/
 

  •  toString 方法的重写：
 


//String类重写了父类的tostring方法
String s = new String("123");
System.out.println(s);

//Arrays也重写了toString方法
int[] a = new int[]{1,2,3};
System.out.println(Arrays.toString(a));


@Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }


 

  • 小结：
 

        1.  Object是所有类的父类，因此所有类型都可以造型成为Object
         2.  Object中提供了toString方法打印了对象的地址信息
         3.  子类可以重写toString方法，改变逻辑体，打印想要的结果
 

 3.equals方法
 


比较字符串的内容:return (this == obj);

 

  • - 对于equals方法，如果没有重写，==和equals完全没有区别
  • - 建议对每一个实体类读添加equals方法，比较属性的值
 


  String s1 = new String("java");
  String s2 = new String("java");
  System.out.println(s1 == s2);   //f
  System.out.println(s1.equals(s2)); //t
  
  Person person = new Person("zhangs",20);
  Person person1 = new Person("zhangs",20);
  System.out.println(person == person1);  //f
  System.out.println(person.equals(person1));  //t   重写了equals方法
  
  
   @Override
      public boolean equals(Object o) {
          if (this == o) return true;  //判断是否传了对象
          if (o == null || getClass() != o.getClass()) return false;  //判断是否传了其他类型
          Person person = (Person) o;
  
          if (age != person.age) return false;  //向下造型
          return name != null ? name.equals(person.name) : person.name == null;
      }
  
      @Override
      public int hashCode() {
          int result = name != null ? name.hashCode() : 0;
          result = 31 * result + age;
          return result;
      }

 

4.equals与==区别
 

  •       1.没有重写时，没有区别，源码的equals也是运用==好去比较的
  •       2.重写了equals后，比较的是属性的值
 

5.实体类的创建
 


* javaBean pojo entity,实体类
*
* 1.定义私有属性
* 2.无参构造方法
* 3.有参构造方法
* 4.set && get 方法
* 5.toString方法
* 6.equals方法

 

创建实体类，属性：uid  uname  pwd
 

public class User {
    private  int uid;
    private  String uname;
    private  String pwd;

    //无参构造方法
    public User() {
    }
    //有参构造方法
    public User(int uid, String uname, String pwd) {
        this.uid = uid;
        this.uname = uname;
        this.pwd = pwd;
    }

    //set && get 方法
    public int getUid() {
        return uid;
    }

    public void setUid(int uid) {
        this.uid = uid;
    }

    public String getUname() {
        return uname;
    }

    public void setUname(String uname) {
        this.uname = uname;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    //重写 toString方法
    @Override
    public String toString() {
        return "User{" +
                "uid=" + uid +
                ", uname='" + uname + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }

    //重写 equals方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        User user = (User) o;

        if (uid != user.uid) return false;
        if (uname != null ? !uname.equals(user.uname) : user.uname != null) return false;
        return pwd != null ? pwd.equals(user.pwd) : user.pwd == null;
    }

    @Override
    public int hashCode() {
        int result = uid;
        result = 31 * result + (uname != null ? uname.hashCode() : 0);
        result = 31 * result + (pwd != null ? pwd.hashCode() : 0);
        return result;
    }
}
 

6.总结
 

1.Object：
 

- ​     1.1 Object是所有类的父类，因此所有类型都可以造型成为Object
 - ​     1.2 Object中提供了toString方法打印了对象的地址信息
 

2.toString方法：
 

- ​     2.1 子类可以重写toString方法，改变逻辑体，打印想要的结果
 - ​     2.2 toString方法是一个常用的调试工具，因此建议给每一个javaBean都添加toString方法
 

3.equals方法
 

- ​     3.1 对于equals方法，如果没有重写，==和equals完全没有区别
 - ​     3.2 建议对每一个实体类读添加equals方法，比较属性的值
 

  • ==号与equals的区别？
 

- 1.没有重写时，两者没有区别，源码中的equals（）也是运用==去比较的
 - 2.重写了equals后，比较的是属性的值
 

4.实体类创建：
 

- 定义私有属性
 - 无参构造方法
 - 有参构造方法
 - set && get 方法
 - toString方法
 - equals方法
 

三、包装类
 

1.概述
 

  •  
    包装类就是基本类型转化成为对象的类(Java.lang.Number类下的子类提供了8种基本类型的包装 类)。
     
  •  
    每一个基本类型都有一个与之对应的包装类(wrapper)。
     
 


   包装类 
 
基本类型包装类型 目录
byte    Byte      java.lang.Number
short  Short      java.lang.Number
int    Interger  java.lang.Number
long    Long      java.lang.Number
float  Float      java.lang.Number
double  Double    java.lang.Number
booleanBoolean    java.lang.Object
char    Character  java.lang.Object
 

2.转换关系
 

  • 包装类 ---> 基本类型：int i.intValue(Integer i)
 

Integer i1 = 1;
System.out.println(i1);
int i2 = i1.intValue();   //将包装类转换为int类型
System.out.println(i2);
 

  • 基本类型 ---> 包装类：Integer.valueOf(int i)
 

int i3 = 12;
Integer i4 = Integer.valueOf(i3);
System.out.println(i4);
 

  • 基本类型 ---> String：String.valueOf(int i)
 

int i5 = 121;
String i6 = String.valueOf(i5);
System.out.println(i6);
 

  • String ---> 基本类型：Integer.parseInt(String str)
 

String i7 = "12";
int i8 = Integer.parseInt(i7);
System.out.println(i8);
 

  • String-->包装类:Integer.parseInt(String str)
 

String str1 = "456";
Integer d = Integer.parseInt(str1);
System.out.println(d);
 

  • 包装类-->String:Integer m.toString()
 

Integer m = 123456;
String str2 = m.toString();
String str3 = String.valueOf(m);
System.out.println(str2);
System.out.println(str3);
 

  •  
    总结：
     
 

         1.八大基本类型都有对应的包装类
 

         2.转换关系：  --包装类 ---> 基本类型：int i.intValue(Integer i)
 

                                --基本类型 ---> 包装类：Integer.valueOf(int i)
 

                                --基本类型 ---> String：String.valueOf(int i)
 

                                --String ---> 基本类型：Integer.parseInt(String str)
 

                                --String-->包装类:Integer.parseInt(String str)
 

                                --包装类-->String:Integer m.toString()
 

3.构造方法
 

//构造方法，传入的参数因与包装类型相匹配
Integer s = new Integer("123456");
System.out.println(s);
 

4.自动装箱和拆箱
 

Integer a = 100;
Integer b = 200;       
Integer c = a + b;
System.out.println(c);
 

 

 

 四、时间日期类
 

1.Date类:生成时间日期对象用Date();
 

  •  
    Java中的时间是用一个固定时间点的毫秒数表示
     
  •  
    纪元(epoch)：1970年1月1日 00:00:00
     
  •  
    常见的时区:
     
 

  1. GMT:格林威治时间
  2. CST:中国时间
  3. UTC:全球标准时间
  4. HST:夏威夷标准时间
 

1.1构造方法
 

       Date对象封装了当前时间
 

Date date = new Date();
System.out.println(date);
          //Sat Apr 09 14:34:31 CST 2022   当前时间
 

1.2setTime和getTime
 

//如何打印明天的当前时间
//方式1:：
Date date1 = new Date();
date1.setTime(System.currentTimeMillis()+86400000);
System.out.println(date1);
//方式2：
long ms = System.currentTimeMillis() + (60*60*24*1000);
Date date2 = new Date(ms);
System.out.println(date2);
 

2.SimpleDateFormat:用固定格式描述日期时间格式
 

2.1构造方法
 

SimpleDateFormat()
用默认的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。
SimpleDateFormat(String pattern)
用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。
 

SimpleDateFormat  simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH-mm-ss");
 

2.2日期匹配字符
 

 

 

2.3常用方法
 

// （日期 -> 文本）
//1.获取日期
Date date1 = new Date();
System.out.println(date);
​
//2.设置文本规则
SimpleDateFormat  simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH-mm-ss");
​
//3.输出文本
String  format = simpleDateFormat.format(date1);    //格式化
System.out.println(format);
​
//（文本 -> 日期）
//1.设置文本
String str = "2022-5-20 : 12:00:00";  //yyyy-M-dd : HH:mm:ss
​
//2.解析文本
SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy-M-dd : HH:mm:ss");
​
//3.获取日期
​
Date date2 = simpleDateFormat1.parse(str);   //自己解决异常，抛出
System.out.println(date2);
 

3.Calender类：时间日期计算
 

  • Calender:抽象类，用于时间分量的计算。
  • GregorianCalendar: 是抽象类Calendar的子类
 

3.1构造方法
 

//1.创建Calendar对象
// Calendar calendar1 = new GregorianCalendar();  //方式1
​
// Calendar calendar2 = Calendar.getInstance();  //方式2
 

//2.传入时间
//方式1
Calendar calendar1 = new GregorianCalendar(2022,4,9,15,27,30);
Date date = calendar1.getTime();
System.out.println(date);
 

​
//方式2
//1.set参数
Calendar calendar2 = Calendar.getInstance();
calendar2.set(2022,4,9);
System.out.println(calendar2.getTime());
 


​
//2.set重写的方式设置时间分量，Calendar中提供 了静态的属性，可以跟属性赋值
calendar2.set(Calendar.HOUR,15);
calendar2.set(Calendar.MINUTE,20);
System.out.println(calendar2.getTime());
 

3.2计算日期分量
 

  • Calendar中提供了很多静态常量，用来描述时间分量
  • 常见时间分量：
 

 

Calendar calendar = Calendar.getInstance();
    calendar.set(Calendar.YEAR,2022);
    //注意：初始值是从0开始的，阳历没有13月，但阴历有
    calendar.set(Calendar.MONTH,12);
    calendar.set(Calendar.DATE,6);
    System.out.println(calendar.getTime());

    //1。一周中的第几天
    int week = calendar.get(Calendar.DAY_OF_WEEK);
    //应该是周四，calendar从周日开始
    System.out.println(week); //6

    //2.一月中的第几周
    int i = calendar.get(Calendar.WEEK_OF_MONTH);
    System.out.println(i);

    //3.一年的第几天
    i = calendar.get(Calendar.DAY_OF_YEAR);
    System.out.println(i);

    //4.当前月的星期几
    i = calendar.get(Calendar.DAY_OF_WEEK_IN_MONTH);
    System.out.println(i);

    //5.22年的最大天数
    i = calendar.getActualMaximum(Calendar.DAY_OF_YEAR);
    System.out.println(i);

    //6.当前月的最大周数
    i = calendar.getActualMaximum(Calendar.WEEK_OF_MONTH);
    System.out.println(i);

     //计算21年的2月的最大天数
        calendar.set(Calendar.MONTH,1);
        System.out.println(calendar.getTime());
        i = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
        System.out.println("最大天数："+i);
}
 

 

 
  

        # java
      
 
 
 Logo 
CSDN学习社区
 
CSDN联合极客时间，共同打造面向开发者的精品内容学习社区，助力成长！
 
 
  
更多推荐
  
cover
 
1 小时解读鸿蒙 10 大热点问题

 
 
avatar CSDN学习社区
 
cover
 
用 OpenAI Assistants 做大模型应用开发
 
 
avatar CSDN学习社区
 
cover
 
1 小时解读鸿蒙 10 大热点问题
 
 
avatar CSDN学习社区