JavaSE基础学习day2--常用API

方法名	说明
public String()	创建一个空白字符串对象，不含有任何内容
public String(char[] chs)	根据字符数组的内容来创建字符串对象
public String(byte[] bys)	根据字节数组的内容（要先创建一个）来创建字符串对象
String s="abc"	直接赋值

1.3 String对象的特点

通过new创建的字符串对象，每一次new一个对象都会申请一个空间，虽然内容相同，但是地址值不同
直接创建的字符串，只要字符序列一模一样，无论在代码中出现几次，都会建立仅一个对象，并在常量池中维护，即一个String对象被创建为“abc”，如果再创建一个String对象内容为abc，则会直接参考上一个对象，本质上前一个和后一个对象是一个对象

内存图：例下

public static void main(String[]args){
    String s="hello";
    s+="world";
    System.out.println(s);
}

a.执行String s="hello"，首先在堆内存开辟常量池的空间，hello的地址值记为001并赋给s，此时s内容为hello

b.s+="world"即为s=s+"world"，首先有个新的字符串world进入常量池并记为002，此时s仍为hello，指向001；接着s+"world"为新的字符串"helloworld"，进入常量池并记为003，然后赋给s，此时s的内容为helloworld

1.4 字符串的比较

1.4.1 用==进行比较

基本类型：直接比较数据值是否相同
引用类型：比较地址值是否相同

1.4.2 用equals（）进行比较

原方法public boolean equals（Object anObject）：只比较字符串的内容是否相同

例：String s1="ab";

String s2="abc";

s1.equals(s2);

1.5 案例

1.5.1 用户登录

已知用户名和密码，用程序实现模拟用户登录，总共三次机会，登陆之后给相应提示

import java.util.*;
public class T1{
    public static void main(String[]args){
        //已知用户名和密码，用字符串定义即可
        String username="Nick";
        String password="123";
        //键盘录入
        for(int i=0;i<3;i++){
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入用户名");
        String usn=sc.nextLine();
        System.out.println("请输入密码");
        String psw=sc.nextLine();
        //进行比较
        
            if(username.equals(usn)&&password.equals(psw)){
                System.out.println("登陆成功");
                break;
            }else { 
            	if(2-i==0) {
            		System.out.println("登录失败，你已被系统绑定");
            	}else {
            		System.out.println("登录失败，你还剩："+(2-i)+"次机会");
            	}
            }
                
            
        }
    }
}

注意：

for循环一定要嵌套住Scanner的录入，否则就算有for循环语句，但是实际上只有一个数据可以比较，无法执行三次。

1.5.2 遍历字符串

键盘录入一个字符串，是程序实现在控制台遍历该字符串

运用public char charAt(int index)方法

import java.util.*;
public class T1{
    public static void main(String[]args){
       Scanner sc=new Scanner(System.in);
       System.out.println("请输入相应的字符串信息：");
       String s=sc.nextLine();
       for(int i=0;i<s.length();i++) {
    	   System.out.print(s.charAt(i));
       }
    }
}

注意：charAt（）是一个方法，需要对象来调用，比如s.charAt()

1.5.3 统计字符次数

键盘录入一个字符串，统计该字符串中大写字符，小写字母字符，数字字符出现的次数（不考虑其他字符）

import java.util.*;
public class T1{
    public static void main(String[]args){
       int bigcount=0;
       int smallcount=0;
       int number=0;
       Scanner sc=new Scanner(System.in);
       System.out.println("请输入字符串信息：");
       String s=sc.nextLine();
       for(int i=0;i<s.length();i++) {
    	   if(s.charAt(i)<='Z'&&s.charAt(i)>='A') {
    		   bigcount++;
    	   }else if(s.charAt(i)<='z'&&s.charAt(i)>='a') {
    		   smallcount++;
    	   }else if(s.charAt(i)<='9'&&s.charAt(i)>='0') {
    		   number++;
    	   }
       }
       System.out.println("大写字母有："+bigcount+"个");
       System.out.println("小写字母有："+smallcount+"个");
       System.out.println("数字有："+number+"个");
    }
}

注意：在判断范围的时候两头都是必须取到的，否则会出现错误

比如：s.charAt(i)<'Z'&&s.charAt(i)>'A'条件时，如果录入AZ，bigcount不会自增

1.5.4 字符串反转

import java.util.*;
public class T1{
    public static void main(String[]args){
       Scanner sc=new Scanner(System.in);
       System.out.println("请输入字符串信息：");
       String line=sc.nextLine();
       String ss=reverse(line);
       System.out.println(ss);
    }
    //定义方法
    public static String reverse(String s) {
    	String ss="";
    	for(int i=s.length()-1;i>=0;i--) {
    		ss+=s.charAt(i);
    	}
    	return ss;
    }
}

注意：如果方法的修饰符没有static，调用方法必须用对象调用，但如果使用static就可以直接用类的对象调用方法

2 StringBuilder类

2.1 概述

为了解决String类中拼接操作导致的耗时浪费空间的问题，我们可以使用Java提供的StringBuilder类

2.2 StringBuilder的构造方法

方法名	说明
public StringBuilder（）	创建一个空白可变字符串对象，不含任何内容
public StringBuilder（String str）	根据字符串的内容，创建可变字符对象

//格式1
StringBuilder sb=new StringBuilder();
System.out.println("sb:"+sb);//结果为打印的内容
System.out.println（"sb.length():"sb.length()）;//打印结果为0
//格式2
StringBuilder sb2=new StringBuilder("hello");
System.out.println("sb2:"+sb2);//结果为打印的内容hello
System.out.println（"sb2.length():"sb2.length()）;//打印结果为5

2.3 StringBuilder的添加和反转方法

方法名	说明
public StringBuilder append（任意类型）	添加数据并返回对象本身
public StringBuilder reverse()	返回相反的字符序列

2.4 Stringbuilder和String的相互转换

StringBuilder转化为String：通过toString（）可以实现

String转化为StringBuilder：通过StringBuilder（String s）实现

例：

String s="abc";

StringBuilder sb=new StringBulider(s);//直接用构造方法

StringBuilder sb2=new StringBuilder("efg");

String ss=sb2.toString();//直接调用相关方法

3.ArrayList类

3.1 集合概述

集合类的特点：提供一种存储空间可变的存储类型，存储的数据容量可以发生改变

ArrayList<E>:

可调整大小的数组实现
<E>是一种特殊的数据类型，泛型，直接用数据类型（char和int特殊）或者类代替即可

3.2 ArrayList构造方法和添加方法

方法名	说明
public ArrayList()	创建一个空的集合对象
public boolean add(E e)	将指定的元素追加到此集合的末尾
public void add(int index, E element)	在集合中的指定位置插入指定元素

例如：

ArrayList<String> array=new ArrayList<String>();

array.add("hello");//如果用打印输出，输出结果会有一个添加是否成功，即true和false，这里直接调用，省略了判断

array.add(1,"cherish");

注意使用插入指定位置的add方法使用时不要超出数组的最大索引，否则会提示索引越界

3.3 ArrayList集合的常用方法

方法名	说明
public boolean remove(Object O)	删除指定的元素，返回删除是否成功
public E remove(int index)	删除指定索引处的元素，返回被删除的元素
public E set(int index,E element)	修改指定索引的元素，返回被删除的元素
public E get(int index)	返回指定索引的位置的值
public int size（）	返回集合中的元素的个数

3.4 案例

3.4.1 存储字符串并遍历

创建一个存储字符串的集合，存储3个字符串元素，并遍历该集合

public class T1{
    public static void main(String[]args){
    	ArrayList<String> array=new ArrayList<String>();
    	array.add("aaa");
    	array.add("bbb");
    	array.add("ccc");
    	for(int i=0;i<array.size();i++) {
    		String arr=array.get(i);
    		System.out.println("第"+(i+1)+"个元素是："+arr);
    	}
    }
    
}

3.4.2 存储学生对象并遍历

创建一个存储学生对象的集合，存储3个对象，并遍历该集合

//定义学生类
public class student {
	private String name;
	private int age;
	public student() {}
	public student(String name,int age) {
		this.name=name;
		this.age=age;
	}
	public void setName(String name) {
		this.name=name;
	}
	public String getName() {
		return name;
	}
	public void setAge(int age) {
		this.age=age;
	}
	public int getAge() {
		return age;
	}
}
//实现需求
public class T1{
    public static void main(String[]args){
    	ArrayList<student> array=new ArrayList<student>();
    	student stu1=new student("小白",12);
    	student stu2=new student("小红",14);
    	student stu3=new student("小黄",16);
    	array.add(stu1);
    	array.add(stu2);
    	array.add(stu3);
    	for(int i=0;i<array.size();i++) {
    		student arr=array.get(i);
    		System.out.println("第"+(i+1)+"个学生是："+arr.getName()+"年龄："+arr.getAge());
    	}
    }
}

注意：获取集合中的元素以后要调用类中的get方法，否则打印出来的只是一个地址值

4.Math类

4.1 Math 类概述

Math包含执行基本数字运算的方法

没有构造方法，如何使用类中的成员？

看类的成员是否是静态的，如果是，则通过类名直接调用即可

4.2Math类的常用方法

方法名	说明
public static int abs(int a)	返回参数的绝对值
public static double ceil(double a)	返回大于或等于参数的最小double值，等于一个整数
public static double floor(double a)	返回小于或等于参数的最大double值，等于一个整数
public static int round(float a)	按四舍五入返回最接近参数的int
public static int max(int a,int b)	返回两个int值中较大的
public static int min(int a,int b)	返回两个int值中较小的
public static double pow(double a,double b)	返回a的b次幂的值
public static double random()	返回值为double的正值，[0.0,1.0)

5.System类

System 类的常见方法

方法名	说明
public static void exit(int status)	终止当前运行的Java虚拟机，非零表示异常终止
public static long currentTimeMills()	返回当前时间（以毫秒为单位）

例如

//计算for循环所用时间
long start=System.currentTimeMills();
for(int i=0;i<100;i++){
    System.out.println(i);
}
long end=System.currentTimeMills();
System.out.println("共耗时："+(end-start)+"毫秒 ");

6.Object类

6.1Object类的概述

Object是所有类的父类，子类构造方法默认是父类的无参构方法的，因为他们的顶级父类只有无参构造方法

6.1.1 Object的toString()方法

直接调用会打印出来地址值，达不到打印的目的，所以需要重写该方法打印对象的属性

Scanner和ArrayList类中打印对象会直接打印其他非地址值，是由于重写了Object类中的toString()方法

6.1.2 Object的equals()方法

Object类的equals方法默认比较两个对象的地址值，没有意义，故需要重写该方法。

但是在比较的时候发现两个对象的数据类型不一样，所以需要用到向下转型去比较

常用一个判断语句if（obj instanceof 待转换类型）判断是否传参会进行转型。

用一个判断语句if（obj==null）判断obj是否为空，提高代码效率

用一个判断语句if（obj==this）判断obj与this本身是否相同，提高代码效率

6.1.3 Objects的equals()方法

为解决普通Object中的对象为空而调用对象时的空指针异常的情况

例如：

String s1=null;
String s2="abc";
boolean b=s1.equals(s2);//此时会报空指针异常，以为Object类中的equals是需要非空对象调用的。

改进：

String s1=null;
String s2="abc";
boolean b2=Objects.equals(s1,s2);//此时就没有空指针异常的问题
//Objects类中的equals方法：对两个对象进行比较，防止空指针异常
public static boolean equals(Object a,Object b){
    return (a==b)||(a!=null&&a.equals(b));
}

7.Arrays类

7.1冒泡排序

如果有n个数据进行排序，总共要比较n-1次；
每次比较完毕，下一次的比较就会少一个数据参加

import java.util.Calendar;
import java.util.Scanner;


public class T1{
    public static void main(String[]args){
    	int []arr= {79,59,25,33,15};
    	System.out.println("排序前："+arrayToString(arr));
    	for(int x=0;x<arr.length-1;x++) {
    		for(int i=0;i<arr.length-1-x;i++) {
    			if(arr[i]>arr[i+1]) {
    				int temp=arr[i];
        			arr[i]=arr[i+1];
        			arr[i+1]=temp;
        		}
    		}
    	}
    	System.out.println("排序后："+arrayToString(arr));
    }
    public static String arrayToString(int []arr) {
    	StringBuilder sb=new StringBuilder();
    	sb.append("[");
    	for(int i=0;i<arr.length;i++) {
    		if(i==arr.length-1) {
    			sb.append(arr[i]);
    		}else {
    			sb.append(arr[i]+",");
    		}
    	}
    	sb.append("]");
    	String s=sb.toString();
    	return s;
    }
}

7.2 Arrays类的概述和常用方法

Arrays类还包含用于操作数组的各种方法

方法名	说明
public static String toString(int[] a)	返回指定数组的内容的字符串表示形式
public static void sort(int[] a)	按照数字顺序排列指定的数组

注意：两个方法均为静态方法，可以直接用类名调用方法

例：

import java.util.Arrays;

public class T1{
    public static void main(String[]args){
    	//定义一个数组
    	int[] arr= {24,36,58,77,59};
    	System.out.println("排序前："+Arrays.toString(arr));
    	Arrays.sort(arr);
    	System.out.println("排序后："+Arrays.toString(arr));
    	
    }
}

7.3 工具类的设计思想

构造方法用private修饰
成员用public static修饰

8.基本类型包装类

将基本数据类型封装成对象的好处就在于可以在对象中定义更多的功能方法操作该数据

常用的操作之一：用于基本数据类型与字符串之间的转换

基本数据类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

8.1 Integer类（其他包装类相似）

8.1.1 概述和使用

Integer：包装一个对象中的原始类型int的值

方法名	说明
public Integer(int value)	根据int值创建Integer对象（过时）
public Integer(String s)	根据String的值创建Integer对象（过时）
public static Integer valueOf(int i)	返回表示指定的int的值的Integer的实例
public static Integer valueOf(String s)	返回一个保存指定值的Integer对象String

例如：Integer i1=new Integer（100）;//用构造方法

        Integer i2=new Integer（"100"）;//用构造方法，而且引用的字符必须是数字字符串否则会出现NumberFormatException异常

  Integer i3= Integer.valueOf（100）;//用静态方法

        Integer i4= Integer（"100"）;//用构造方法

8.1.2 int和String的相互转换

int转换为String

public static String valueOf(int i):返回int参数的字符串表示形式。该方法是String中的方法

String转换为int

public static int valueOf(String s):将字符串解析为int类型，该方法是Integer中的方法

8.2* 案例

有一个字符串：“91 27 46 38 50”请写出程序实现最终输出是“27 38 46 50 91”

import java.util.Arrays;

public class T1{
    public static void main(String[]args){
    //定义一个字符串
    String s="91 46 27 38 50";
    //把字符串中的每个元素放进String类型的数组中
    String[] strArray =s.split(" ");
  
    //定义一个int数组，把String类型的数组存储到int类型的数组中
    int []arr=new int[strArray.length];
    for(int i=0;i<arr.length;i++) {
    	arr[i]=Integer.parseInt(strArray[i]);
    }
    //对int数组进行排序
    Arrays.sort(arr);//冒泡排序
    //把排序后的int数组中的元素拼接得到一个字符串
    StringBuilder sb=new StringBuilder();
    for(int i=0;i<arr.length;i++) {
    	if(i==arr.length-1) {
    		sb.append(arr[i]);
    	}else {
    		sb.append(arr[i]).append(" ");
    	}
    }
    String ss=sb.toString();
    System.out.println(ss);
    }
}

8.3 自动装箱和拆箱

装箱：把基本数据类型转换为对应的包装类型
拆箱：把包装类类型转换为对应的基本数据类型

Integer i=100 //自动装箱，但内含Integer.valueOf（100）这个操作

i+=200;//自动拆箱+装箱，i+200是自动拆箱，但内含i=i.intValue()+200这个操作，i=i+200；是自动装箱

注意：再使用包装类类型的时候，先判断是否为null，建议只要是对象都先判空

9.Date类

9.1 Date类的概述和构造方法

Data代表了一个特定的事件，精确到毫秒

方法名	说明
public Date（）	分配一个Date对象，并初始化，以便它代表它被分配的事件，精确到毫秒
public Date（long date）	分配一个Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数

9.2 Date类的常用方法

方法名	说明
public long getTime()	获取的日期对象是从1970年1月1日00:00:00到现在的毫秒值
public void setTimeTime(long time)	设置时间，给的是毫秒值

9.3 SimpleDateFormat类概述

SimpleDateFormat是一个具体的类，用于以区域设置敏感的方式格式化和解析日期。

日期和时间格式由日期和时间模式字符串指定，在日期和时间模式字符串中，从'A'到'Z'以及从'a'到'z'引号的字母被解释为表示日期货时间字符串的组件的模式字母

常用的模式字母以及对应关系如下：

y 年
M 月
d 日
H 时
m 分
s 秒

9.4 SimpleDateFormat的构造方法

方法名	说明
public SimpleDateFormat()	构造一个SimpleDateFormat，使用默认模式和日期格式
public SimpleDateFormat(String pattern)	构造一个SimpleDateFormat使用给定的模式和默认的日期格式

9.5 SimpleDateFormat格式化和解析日期

1.格式化（从Date到String）

public final String format(Date date):将日期格式化为日期/时间字符串

2.解析（从String到Date）

public Date parse(String source):从给定字符串的开始解释文本以生成日期

例如：

import java.util.Date;
import java.text.ParseException;
import java.text.SimpleDateFormat;

public class T1{
    public static void main(String[]args) throws ParseException {
    	//格式化
    	Date d=new Date();
    	SimpleDateFormat sdf=new SimpleDateFormat();
    	String s=sdf.format(d);
    	System.out.println(s);
    	SimpleDateFormat sdf1=new SimpleDateFormat("yyyy年MM月dd日 HH：mm：ss");
    	String s2=sdf1.format(d);
    	System.out.println(s2);
    	System.out.println("---------------");
    	//解析
    	String ss="2048-08-19 12:12:12";
    	SimpleDateFormat sdf2=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    	Date dd=sdf2.parse(ss);
    	System.out.println(dd);
    }
}

注意：

1.date的拼写

2.使用parse方法时用抛出异常解决

3.解析的时候格式一定要一模一样，否则标点符号错了都会报错

10.Calendar类

10.1概述

Calendar为某一时刻和一组日历字段之间的转换提供了一些方法，并为操作日历字段提供了一些方法

Calendar提供了一个类方法getInstance用于获取 Calendar对象，其日历字段已使用当前日期和时间初始化; CalendarrightNow=Calendar.getInstance();

例如：

public class CalendarDemo{
    public static void main(String[]args){
        Calendar c=Calendar.getInstance();//多态的形式
        //public int get(int field)获取对应的年月日的值
        int year =c.get(Calendar.YEAR);
        int month=c.get(Calendar.MONTH)+1//输出是从0开始的;
        int date =c.get(Calendar.Date);
        System.out.println(year+"年"+month+"月"+date+"日");
    }
}

10.2 Calendar的常用方法

方法名	说明
public int get(int field)	返回给定日历字段的值
public abstract void add(int field,int amount)	根据日历的规则，将指定的时间两添加或减去给定的日历字段
public final void set(int year,int month,int date)	设置当前日历的年月日

c.add(Calendar.YEAR,-1);//一年前

c.add(Calendar.DATE,20);//20天后

c.set（2024,11,21）;

10.3 案例

获取任意一年的二月有多少天

import java.util.Calendar;
import java.util.Scanner;


public class T1{
    public static void main(String[]args){
    	//键盘录入年
    	Scanner sc=new Scanner(System.in);
    	System.out.println("请输入年份：");
    	int year=sc.nextInt();
    	//设置日历对象
    	Calendar c=Calendar.getInstance();
    	c.set(year,2,1);
    	//3.1往前推一天就是2月的最后一天
    	c.add(Calendar.DATE, -1);
    	//输出这一天
    	int date=c.get(Calendar.DATE);
    	System.out.println(year+"年的2月有"+date+"天");
    }
}