java基础（常用类）

最新推荐文章于 2023-07-28 10:35:33 发布

Taiiiii

最新推荐文章于 2023-07-28 10:35:33 发布

阅读量134

点赞数

本文链接：https://blog.csdn.net/Taiiiii/article/details/107124294

版权

JAVA 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

文章目录

常用API

常用API

API 应用程序编程接口

Object类的toString()方法

/**
 * object ：是类层次的根类，所有类都直接或间接继承该类
 *
 * 直接输出对象名，输出底层调用的是该对象的toString（）
 *
 * 查看api，建议所有子类都重写tostring
 *
 *
 * ==：
 *      可以比较基本数据类型，比较基本数据类型的时候比较的是基本数据类型的值是否相同
 *
 *
 * object默认的eqials（）方法默认比较的是对象的地址是否相同
 *
 * 如果我们想比较对象的内容是否相同，就必须自己重写该方法
 * ctrl+o  可以自动生成
 *
 */

String类的概述和构造方法

/**
 * srting ： 代表字符串类
 *
 *  string 类创建对象的特点：
 *          1、 通过构建方法创建对象  String s1 = new String("hellow");
 *          2. 通过直接赋值创建对象   String s1 = "hellow";
 *
 *  第一种 创建 是真的重新创建一个
 *  第二种 是在常量池创建一个，以后相同的值都会指向这里
 */

package com.company;

import java.util.Scanner;
/**
 *  需求：模拟登陆，给三次机会，并提示还有几次
 *  分析：
 *          1. 定义两个字符串对象，存储已经存在的用户名和密码
 *          2. 键盘录入用户名和密码
 *          3. 拿键盘录入的用户名和密码跟已经存在的用户名和密码进行比较
 *              如果相同，提示登陆成功
 *              如果不同，就提示登陆失败，并提示还有几次机会
 *
 *
 */
public class Main {

    public static void main(String[] args) {
        //定义两个字符串对象，用于存储已经存在的用户名和密码
        String username = "admin";
        String password = "admin";

        for(int x=0; x<3; x++) {
            //键盘录入用户名和密码
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入用户名：");
            String name = sc.nextLine();
            System.out.println("请输入密码：");
            String pwd = sc.nextLine();

            //拿键盘录入的用户名和密码去跟已经存在的用户名和密码进行比较
            if(username.equals(name) && password.equals(pwd)) {
                System.out.println("登录成功");
                break;
            }else {
                if((2-x) == 0){
                    System.out.println("你的帐号被锁定，请与管理员联系");
                }else {
                    System.out.println("登录失败，你还有"+(2-x)+"次机会");
                }
            }
        }
    }
}

package com.company;

import java.util.Scanner;
/*
 * 需求：把数组中的数据按照指定个格式拼接成一个字符串
 * 举例：int[] arr = {1,2,3};
 * 输出结果：[1, 2, 3]
 *
 * 分析：
 * 		A:定义一个int类型的数组
 * 		B:写方法实现把数组中的元素按照指定的格式拼接成一个字符串
 * 		C:调用方法
 * 		D:输出结果
 */

public class Main {

    public static void main(String[] args) {
        //定义一个int类型的数组
        int[] arr = {1,2,3};

        //写方法实现把数组中的元素按照指定的格式拼接成一个字符串

        //调用方法
        String result = arrayToString(arr);

        //输出结果
        System.out.println("result:"+result);
    }

    /*
     * 两个明确：
     * 		返回值类型：String
     * 		参数列表：int[] arr
     */
    public static String arrayToString(int[] arr) {
        String s = "";
        //[1, 2, 3]
        s+="[";

        for(int x=0; x<arr.length; x++) {
            if(x==arr.length-1) {
                s += arr[x];
            }else {
                s += arr[x];
                s += ", ";
            }
        }

        s+="]";
        return s;
    }
}

StringBuilder的概述

String 的内容是固定的
StringBuilder的内容是可变的

A:构造方法:
public StringBuilder()
public StringBuilder(String str)
B:成员方法:
public String toString():返回此序列中数据的字符串表示形式。
public StringBuilder append(任意类型):添加数据，并返回对象本身。
public StringBuilder reverse():字符串本身进行反转

小测验：

package com.company;


/**
 * 把数组拼接成一个字符串
 * 举例：int[] arr = {1,2,3};
 * 输出结果：[1, 2, 3]
 *
 * 分析：
 * 		A:定义一个int类型的数组
 * 		B:写方法实现把数组中的元素按照指定的格式拼接成一个字符串
 * 		C:调用方法
 * 		D:输出结果
 *
 */


public class Main {

    public static void main(String[] args) {
        //定义一个int类型的数组
        int[] arr = {1,2,3};

        //写方法实现把数组中的元素按照指定的格式拼接成一个字符串

        //调用方法
        String result = arrayToString(arr);

        //输出结果
        System.out.println("result:"+result);
    }

    /*
     * 两个明确：
     * 		返回值类型：String
     * 		参数列表：int[] arr
     */
    public static String arrayToString(int[] arr) {
        StringBuilder sb = new StringBuilder();
        //[1, 2, 3]
        sb.append("[");

        for(int x=0; x<arr.length; x++) {
            if(x==arr.length-1) {
                sb.append(arr[x]);
            }else {
                sb.append(arr[x]).append(", ");
            }
        }

        sb.append("]");

        String s = sb.toString();

        return s;

    }
}

package com.company;


import java.util.Scanner;

/**
 * 把字符串反转
 * 举例：键盘录入”abc”
 * 输出结果：”cba”
 *
 * 分析：
 * 		A:键盘录入一个字符串数据
 * 		B:写方法实现字符串数据的反转
 * 			String -- StringBuilder -- reverse() -- String
 * 		C:调用方法
 * 		D:输出结果
 */



public class Main {
    public static void main(String[] args) {
        //键盘录入一个字符串数据
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String s = sc.nextLine();

        //写方法实现字符串数据的反转

        //调用方法
        String result = myReverse(s);

        //输出结果
        System.out.println("result:"+result);

    }

    /*
     * 两个明确：
     * 		返回值类型：String
     * 		参数列表：String s
     */
    public static String myReverse(String s) {
        //String -- StringBuilder -- reverse() -- String
		/*
		StringBuilder sb = new StringBuilder(s);
		sb.reverse();
		String ss = sb.toString();
		return ss;
		*/

        return new StringBuilder(s).reverse().toString();
    }
}

Arrays类

package com.company;

import java.util.Arrays;

/*
 * Arrays:提供了对数组操作的各种方法。
 * public static String toString(int[] a):把数组转成字符串
 * public static void sort(int[] a):对数组进行升序排序
 */
public class Main {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {24,69,80,57,13};

        //public static String toString(int[] a):把数组转成字符串
        System.out.println("排序前："+Arrays.toString(arr));

        //public static void sort(int[] a):对数组进行升序排序
        Arrays.sort(arr);

        System.out.println("排序后："+Arrays.toString(arr));
    }
}

Arrays类中有构造方法，只不过构造方法被private修饰，外界是无法使用的。
Arrays类的这种设计是常用的工具类的设计思想：
构造方法私有。
成员都用static修饰。

基本类型包装类

package com.company;



/*判断一个数据是否在int范围内
基本类型包装类：
		Byte	byte
		Short	short
		Integer	int
		Long	long
		Float	float
		Double	double
		Character	char
		Boolean	boolean
基本数据类型包装类最常见的用法就是用于和字符串之间进行相互转换
 */
public class Main {
    public static void main(String[] args) {
        //public static final int MAX_VALUE
        //static 修饰可以用类名直接访问
        System.out.println(Integer.MAX_VALUE);
        //public static final int MIN_VALUE
        System.out.println(Integer.MIN_VALUE);
    }
}

Integer类

package com.company;

/*
 * Integer:Integer类在对象中包装了一个基本类型 int 的值。
 *
 * 构造方法：
 * 		Integer(int value)
 * 		Integer(String s)
 * 			注意：这个字符串必须由数字字符组成
 */

public class Main {
    public static void main(String[] args) {
        //Integer(int value)
        int value = 100;
        Integer i = new Integer(value);
        System.out.println(i); //100
        System.out.println("------------");

        //Integer(String s)
        String s = "100";
        //NumberFormatException:数据格式化异常
        //String s = "abc";
        Integer ii = new Integer(s);
        System.out.println(ii);

    }
}

package com.company;

/*
 * int类型和String类型的相互转换
 *
 * int	--	String
 * 		String类中：public static String valueOf(int i)
 *
 * String	--	int
 * 		Integer类中：public static int parseInt(String s)
 */

public class Main {
    public static void main(String[] args) {
        //int	--	String
        int number = 100;
        //方式1
        String s1 = "" + number;
        System.out.println(s1);
        //方式2
        //public static String valueOf(int i)
        String s2 = String.valueOf(number);
        System.out.println(s2);
        System.out.println("--------------");

        //String  -- int
        String s = "100";
        //方式1
        //String -- Integer -- int
        Integer i = new Integer(s);
        //public int intValue()
        int x = i.intValue();
        System.out.println(x);
        //方式2
        //public static int parseInt(String s)
        int y = Integer.parseInt(s);
        System.out.println(y);

    }
}

// 练习：：
package com.company;

import java.util.Arrays;

/*
 * /*
 * 我有如下一个字符串:”91 27 46 38 50”
 * 请写代码实现最终输出结果是：”27 38 46 50 91”
 * 提示：这里需要参考String类中的方法
 * public String[] split(String regex)
 * * 分析：
 * 		A:定义一个字符串对象
 * 		B:把字符串中的数字数据存储到一个int类型的数组中
 * 		C:对int数组进行排序
 * 		D:把排序后的数组中的元素进行拼接得到一个字符串
 * 		E:输出字符串
 */

public class Main {
    public static void main(String[] args) {
        //定义一个字符串对象
        String s = "91 27 46 38 50";

        //把字符串中的数字数据存储到一个int类型的数组中
        //public String[] split(String regex)
        String[] strArray = s.split(" ");
		/*
		for(int x=0; x<strArray.length; x++) {
			System.out.println(strArray[x]);
		}
		*/

        //定义一个int类型的数组
        int[] arr = new int[strArray.length];
        for(int x=0; x<arr.length; x++) {
            arr[x] = Integer.parseInt(strArray[x]);
        }

        //对int数组进行排序
        Arrays.sort(arr);

        //把排序后的数组中的元素进行拼接得到一个字符串
        StringBuilder sb = new StringBuilder();
        for(int x=0; x<arr.length; x++) {
            if(x==arr.length-1) {
                sb.append(arr[x]);
            }else {
                sb.append(arr[x]).append(" ");
            }
        }
        String result = sb.toString();

        //输出字符串
        System.out.println("result:"+result);

    }
}

package com.company;

import java.util.Arrays;

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

 *
 */

public class Main {
    public static void main(String[] args) {
        //创建一个包装类类型的对象
        //Integer i = new Integer(100);
        Integer ii = 100; //自动装箱
        //public static Integer valueOf(int i)
        ii += 200; //ii = ii + 200; 自动拆箱,自动装箱
        //public int intValue()
        System.out.println(ii);

		/*
		Integer ii = Integer.valueOf(100);
		ii = Integer.valueOf(ii.intValue() + 200);
		System.out.println(ii);
		*/

        Integer iii = null;
        if(iii != null) {
            iii += 300; //NullPointerException
            System.out.println(iii);
        }

    }
}

Date类

package com.company;

import java.util.Date;

/*  Date:Date表示特定的瞬间，精确到毫秒。
 *
 * 构造方法：
 * 		Date():根据当前时间创建的日期对象
 * 		Date(long date):根据给定的毫秒值创建对象，从1970 年 1 月 1 日 00:00:00

 */

public class Main {
    public static void main(String[] args) {
        //Date()
        Date d = new Date();
        System.out.println(d);

        //Date(long date)
        long date = 1000 * 60 * 60;
        Date dd = new Date(date);
        System.out.println(dd);

    }
}

package com.company;

import java.util.Date;

/*  public long getTime():获取的是毫秒值。从1970年1月1日 00:00:00开始的。
 * public void setTime(long time):设置时间，给的是毫秒值。
 *
 * 从Date得到一个毫秒值：
 * 		getTime()
 *
 * 从一个毫秒值得到一个Date对象
 * 		构造方法
 * 		setTime(long time)

 */

public class Main {
    public static void main(String[] args) {
        //创建对象
        Date d = new Date();

        //public long getTime()
        System.out.println(d.getTime());

        //public void setTime(long time)
        d.setTime(1000*60*60);
        System.out.println(d.getTime());

    }
}