Java -进阶一

小安同学iter

已于 2024-10-06 15:50:28 修改

阅读量219

点赞数 10

分类专栏： java 文章标签： java 开发语言

于 2024-09-22 16:04:29 首次发布

本文链接：https://blog.csdn.net/2302_79847831/article/details/142435863

版权

java 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

ctrl+alt+L=自动格式化
ctrl+shift+F10=运行当前代码
ctrl+alt+M=选中代码块创建方法
ctrl+alt+shift+T重命名
ctrl+alt+V=(数据).var进行自动补全
(数据).sout自动补全
alt+7=方法查询
ctrl+Z撤销

常用工具

1 System

可以获取当前时间，以此计算运行代码的时间
也可以控制代码的结束


 //获取当前时间点-毫秒 1970 1-1 8:00
long num = System.currentTimeMillis();
System.out.println(num);

//系统退出运行
System.exit(0);

2 Runtime

获取操作系统的线程大小
能从操作系统最多获取多少内存大小
已经获取的获取的内存大小-M 
剩下的内存大小
在固定时间关机与取消

//获取操作系统的线程大小
int nums = Runtime.getRuntime().availableProcessors();
System.out.println(nums);

//能从操作系统最多获取多少内存大小
long l = Runtime.getRuntime().maxMemory();
System.out.println(l / 1024 / 1024);

//已经获取的获取的内存大小
long L = Runtime.getRuntime().totalMemory();
System.out.println(L / 1024 / 1024);

//剩下的内存大小
long LL = Runtime.getRuntime().freeMemory();
System.out.println(LL / 1024 / 1024);

//在固定时间关机与取消
Runtime.getRuntime().exec("shutdown -s -t 3600");
Runtime.getRuntime().exec("shutdown -a");


System.exit(0);

3 equals

import java.util.Objects;

public class Equals {
    String name;
    int age;

    public Equals(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Equals() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Equals equals = (Equals) o;
        return age == equals.age && Objects.equals(name, equals.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

public class BiEqual {
    public static void main(String[] args) {

        Equals a1 = new Equals("ax", 11);
        Equals a2 = new Equals("ax", 11);
        boolean w = a1.equals(a2);
        System.out.println(w);
        //这里的比较默认的是对象的地址，如果想要比较具体的参数值需重写
        String s = "ax";
        StringBuilder sb = new StringBuilder("ax");
        boolean equals = s.equals(sb.toString());
        boolean equals1 = s.equals(sb);
        boolean equals2 = sb.equals(s);
        System.out.println(equals);
        System.out.println(equals1);
        System.out.println(equals2);
        //String中的String中的equals方法是先判断是否为字符串，如果不是字符串那再继续比较其他属性
        //StringBuilder中没有重写特定的equals方法只能从obj中继承
        //obj中equals比较的是对象的地址



    }

}

4 Objects下的equqls可以有非空判断

5 clone

浅克隆与深克隆（在于引用数据类型数组的更改变化）

对象拷贝：clone方法是protected只可以在子类中被调用，在这里需要重写

并且java类中要继承Cloneable接口

该接口没有抽象方法，是一个标记性接口

Cloneable实现当前类可以被克隆，没有实现当前类的对象不可以被克隆

浅克隆，浅拷贝：

javabean类

public class CloneStudent implements Cloneable {
    String name;
    int age;
    int[] arr;

    public CloneStudent(String name, int age, int[] arr) {
        this.name = name;
        this.age = age;
        this.arr = arr;
    }

    public CloneStudent() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int[] getArr() {
        return arr;
    }

    public void setArr(int[] arr) {
        this.arr = arr;
    }

    public void getCloneArr() {
        for (int j : arr) {
            System.out.print(j + " ");
        }
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

实现类

public class CloneTest {
    public static void main(String[] args) throws CloneNotSupportedException {


        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        CloneStudent cs = new CloneStudent("ax", 19, arr);

        CloneStudent css = (CloneStudent) cs.clone();

        cs.getArr()[0] = 100;

        System.out.println(cs.getAge() + " " + cs.getName());
        cs.getCloneArr();
        System.out.println();
        System.out.println(css.getAge() + " " + css.getName());
        css.getCloneArr();
    }
}

深克隆，深拷贝：

javabean（这里的clone方法需要重写需求）

public class CloneStudent implements Cloneable {
    String name;
    int age;
    int[] arr;

    public CloneStudent(String name, int age, int[] arr) {
        this.name = name;
        this.age = age;
        this.arr = arr;
    }

    public CloneStudent() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int[] getArr() {
        return arr;
    }

    public void setArr(int[] arr) {
        this.arr = arr;
    }

    public void getCloneArr() {
        for (int j : arr) {
            System.out.print(j + " ");
        }
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        int[] a = this.arr;
        int[] a1 = new int[a.length];
        for (int i = 0; i < a.length; i++) {
            a1[i] = a[i];
        }
        CloneStudent clone = (CloneStudent) super.clone();
        clone.setArr(a1);

        return clone;
    }
}

测试类

public class CloneTest {
    public static void main(String[] args) throws CloneNotSupportedException {


        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        CloneStudent cs = new CloneStudent("ax", 19, arr);

        CloneStudent css = (CloneStudent) cs.clone();

        cs.getArr()[0] = 100;

        System.out.println(cs.getAge() + " " + cs.getName());
        cs.getCloneArr();
        System.out.println();
        System.out.println(css.getAge() + " " + css.getName());
        css.getCloneArr();
    }
}

执行结果

6 BigInteger

7BigDecimal

1 通过传递double类型的小数来创建对象（这种情况可能会不准确）

BigDecimal bigDecimal6 = new BigDecimal(1.2262);
BigDecimal bigDecimal7 = new BigDecimal(0.0001);
System.out.println(bigDecimal6);
System.out.println(bigDecimal7);

double a = 1.226;
double b = 1.2262;
BigDecimal bigDecimal2 = new BigDecimal(a);
BigDecimal bigDecimal3 = new BigDecimal(b);
System.out.println(bigDecimal2);
System.out.println(bigDecimal3);

运行结果：

2 通过传递字符串类型的小数

BigDecimal bigDecimal4 = new BigDecimal("1.2262");
BigDecimal bigDecimal5 = new BigDecimal("0.0001");
System.out.println(bigDecimal4);
System.out.println(bigDecimal5);

运行结果：

3 通过使用静态方法valueOf()来调用

double a = 1.226;
double b = 1.22542;
double c = a+b;
System.out.println(c);
        
BigDecimal bigDecimal = BigDecimal.valueOf(a);
BigDecimal bigDecimal1 = BigDecimal.valueOf(b);
BigDecimal add = bigDecimal1.add(bigDecimal);
System.out.println(add);

运行结果：

如果表示的数没有超过double推荐使用静态方法，如果超过推荐使用构造方法。

四则运算：

1 加

double a = 1.21132;
double b = 1.22542;
BigDecimal bigDecimal = BigDecimal.valueOf(a);
BigDecimal bigDecimal1 = BigDecimal.valueOf(b);
//加
BigDecimal num1 = bigDecimal.add(bigDecimal1);
System.out.println(num1);

2 减

//减
BigDecimal num2 = bigDecimal.subtract(bigDecimal1);
System.out.println(num2);

3 乘

//乘
BigDecimal num3 = bigDecimal.multiply(bigDecimal1);
System.out.println(num3);

4 除

//除 - 该种方法对可以整除的有效，无法整除将出错需要保留小数
//BigDecimal num4 = bigDecimal1.divide(bigDecimal);

BigDecimal num5 = bigDecimal1.divide(bigDecimal, 5,RoundingMode.HALF_UP);
System.out.println(num5);

//也可以利用setScale来对小数进行位数格式化
BigDecimal value = new BigDecimal("3.14159265");
BigDecimal roundedValue = value.setScale(5, RoundingMode.HALF_UP);
System.out.println(roundedValue);

位数保留：

//RoundingMode.HALF_UP 四舍五入进位
//RoundingMode.HALF_DOWN 五舍六入进位
//RoundingMode.UP 往远离0的方向进位
//RoundingMode.DOWN 往靠近0的方向进位
//RoundingMode.CEILING 往正无穷大的方向进位
//RoundingMode.FLOOR 往负无穷大的方向进位

8 正则表达式

1 判断一个字符是不是在 aghsw这几个字符中

System.out.println("a".matches("[aghsw]"));

2 判断一个字符是不是在 aghsw这个字符之外

System.out.println("a".matches("[^aghsw]"));

3 判断一个字符是不是在某个范围之内

System.out.println("a".matches("[a-cf-h0-8]"));

System.out.println("a".matches("[a-c[f-h][0-8]]"));

4 判断一个字符在一个范围内（交集）

System.out.println("a".matches("[a-f&&[^b-c]]"));
System.out.println("b".matches("[a-z[A-Z]&&[^c-f]]"));

注意：

遵循一个中括号一个字符，在中括号里面可以再次使用中括号进行区别

5 判断一个字符在任意字符中（这种情况下不需要加【】）

System.out.println("aa".matches(".."));

6 判断一个字符为数字0-9（不需要加【】）

System.out.println("32".matches("\\d[2]"));

7 判断一个字符为非数字（不需要加【】）

System.out.println("N2".matches("\\D[2]"));

8 判断一个字符为空白字符（不需加【】）

System.out.println("\t".matches("\\s"));
System.out.println(" ".matches("\\s"));
System.out.println("\f".matches("\\s"));
System.out.println("\n".matches("\\s"));

9 判断一个字符不是空白字符（不需要加【】）

System.out.println("aa".matches("\\S[a]"));

10 判断一个字符是英文字符下划线数字（不需要加【】）

System.out.println("aa_".matches("\\w[a]\\w"));

11 判断一个字符非单词字符^w(不需要加【】)

System.out.println("aa_".matches("\\w[a]\\W"));

12 判断一个字符出现次数为一次或0次

System.out.println("2".matches("\\w?"));

13 判断一个字符出现0次或者多次

System.out.println("adsa12323".matches("\\w*"));

14 判断一个字符出现1次或者多次

System.out.println(" ".matches("\\w+"));

9 Data时间模块

获取当前时间

Date date = new Date();
System.out.println(date);

获取起始时间

Date date1 = new Date(0);
System.out.println(date1);

构造时间

Date date2 = new Date(18283080913232L);
System.out.println(date2);

时间的格式化

SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss EE");
Date date3 = new Date(0);
System.out.println(sdf.format(date3));

eg 得到今天距离元旦还有多少天

//获取今天到元旦还有多少天
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
//当前时间以及毫秒数
Date date4 = new Date();
System.out.println(sdf1.format(date4));
long date4Time = date4.getTime();
//解析元旦的时间
String s = "2025年01月01日 00:00:00";
Date parse = sdf1.parse(s);
System.out.println(sdf.format(parse));
long time = parse.getTime();
long t = time - date4Time;
System.out.println(t/1000/60/60/24);

10 String类

1字符串的构造方法：

public class an2{
    public static void main(String[] args){
        //直接构造
        String stringArray = "anxian";
        System.out.println(stringArray);
        //使用空参构造
        String stringArray2 = new String();
        stringArray2="anxian";
        System.out.println(stringArray2);

        //使用字符数组创建
        char [] stringArray3 = {'a','b','c'};
        String stringArray4 = new String(stringArray3);
        System.out.println(stringArray4);
        
        //使用字节数组创建
        byte [] stringArray5 = {97,98,99};
        String stringarray6 =new String(stringArray5);
        System.out.println(stringarray6);

运行结果：

2.常量池

Java基本类型和引用类型的区别_java基本类型和引用类型区别-CSDN博客

3 .字符串的比较

（这种情况不受构造方法的影响）

（常量尽量写在前面，以免出现null值报错）

1 equals

public class an2{
    public static void main(String[] args){
        String Str = "anxian";

        String Str2="anxian1";

        System.out.println(Str.equals(Str2));

运行结果：

2 equalsIgnorecase

（这种方法忽略大小写）

import java.util.*;
public class an2{
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);

        String axStr = input.nextLine();

        String Str = "anxian";

        System.out.println(axStr.equalsIgnoreCase(Str));

运行结果：

3.字符串长度：

import java.util.*;
public class an2{
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);

        String axStr = input.nextLine();

        int axLength = axStr.length();

        System.out.println(axLength);

运行结果：

4.拼接字符串

import java.util.*;
public class an2{
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);

        String axStr = input.nextLine();

        String axStr2 = axStr.concat(" World");

        System.out.println(axStr2);

运行结果：

5.获取单个字符：

可选择指定索引（下标）位置。

import java.util.*;
public class an2{
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);

        String axStr = input.nextLine();

        char axChar = axStr.charAt(2);

        System.out.println(axChar);

运行结果：

6.子字符串的索引（首个）

import java.util.*;
public class an2{
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);

        String axStr = input.nextLine();

        int numAX = axStr.indexOf("an");

        System.out.println(numAX);

运行结果：

7.截取字符串

import java.util.*;
public class an2{
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);

        String axStr = input.nextLine();

        String ax = axStr.substring(2);//截取2：-1

        String axXian = axStr.substring(1,3);//截取1：3

        System.out.println(ax+" "+axXian);

运行结果：

8.将String的转换为数组：

字符char数组

字节byte数组

public class an4 {
    public static void main(String[] args){
        String aXian = "Hello World";

        char [] charaXian = aXian.toCharArray();

        byte [] byteaXian = aXian.getBytes();

        for (char ch : charaXian){
            System.out.print(ch+" ");
        }
        System.out.println();
        for (byte b : byteaXian){
            System.out.print(b+" ");
        }
    }
}

运行结果：

9.replace用法

public class an4 {
    public static void main(String[] args){
        String aXian = "Hello World My friends";
        String language = "会不会玩，你个大傻逼";

        String MaXian = aXian.replace(" ","|");

        String Mlanguage =language.replace("傻逼","**");

        System.out.println(MaXian);
        System.out.println(Mlanguage);
    }
}

运行结果：

10.split()用法

split()的参数实际上是一个正则表达式

public class an4 {
    public static void main(String[] args) {
        String aXian = "Hello World My friends";

        String[] ax = aXian.split(" ");//String数组


        for (String i :ax){
            System.out.print(i+"\t");
        }
    }
}

运行结果：

11.String的具体练习：

输入一个字符串然后统计这个字符串中大写小写数字以及其他出现的次数。

import java.util.*;
public class an5 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        String axStr = input.nextLine();
        char [] axChar = axStr.toCharArray();
        int aStr = 0;
        int AStr = 0;
        int IStr = 0;
        int OStr = 0;
        for (int i = 0; i < axChar.length; i++) {
            char ch = axChar[i];
            if (ch >= 'A' &&  ch <= 'Z') {
                AStr += 1;
            }else if (ch >= 'a' &&  ch <= 'z') {
                aStr += 1;
            }else if (ch >= '0' &&  ch <= '9') {
                IStr += 1;
            }else{
                OStr += 1;
            }
        }
        System.out.println("大写"+AStr);
        System.out.println("小写"+aStr);
        System.out.println("数字"+IStr);
        System.out.println("其他"+OStr);
    }
}

运行结果：

11 Arrays类

java.util.Arrays;是一个与数组相关的工具类，里面提供了大量的静态方法，用来实现数组常见操作，

1.将数组变成字符串

将参数数组变成字符串，按照默认格式【元素1，元素2，元素3~~~】

import java.util.Arrays;
public class an6 {
    public static void main(String[] args) {
        int[] axInt = {1,2,3,4};
        
        String axStr = Arrays.toString(axInt);
        
        System.out.println(axStr);
    }
}

运行结果：

2.sort 升序排序

import java.util.Arrays;
public class an6 {
    public static void main(String[] args) {
        int[] axInt = {1,2,3,4,8,5,7,99,88,77,55,444,3333};

        Arrays.sort(axInt);
        
        String axStr = Arrays.toString(axInt);

        System.out.println(axStr);
    }
}

运行结果：

3 查找数组中的元素所在的索引值

（否则返回应该在的位置加1取负数）

import java.util.Arrays;

public class Arr {
    public static void main(String[] args) {
        int[] arr = new int[]{1, 2, 99, 33, 222, 12, 3, -1, 4, 5};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        int i = Arrays.binarySearch(arr, 5);
        System.out.println(i);

    }
}

运行结果：

4 拷贝数组

import java.util.Arrays;

public class Arr {
    public static void main(String[] args) {
        int[] arr = new int[]{1, 2, 3, 4, 5};
        //第二个参数写需要拷贝的新数组长度，如果长了给默认值，短了就从第一个数进行截取
        int[] arr2 = Arrays.copyOf(arr, arr.length);
        System.out.println(Arrays.toString(arr2));
        //第二个第三个参数写拷贝的原数组的索引值
        int[] arr3 = Arrays.copyOfRange(arr, 2, 4);
        System.out.println(Arrays.toString(arr3));
    }
}

运行结果：

5数组的覆盖填充

import java.util.Arrays;
import java.util.Comparator;

public class Arr {
    public static void main(String[] args) {

        Integer[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        Arrays.fill(arr, 1);
        System.out.println(Arrays.toString(arr));
    }
}

运行结果：

6 给定一个数组进行倒序输出

import java.util.Arrays;
import java.util.Comparator;

public class Arr {
    public static void main(String[] args) {

        Integer [] arr = {1,2,3,4,5,6,7,8,9};
        Arrays.sort(arr,new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        });
        System.out.println(Arrays.toString(arr));
    }
}

运行结果：

7 对象的特征排序

Girlfriend类

public class GirlFriends {
    private String name;
    private int age;
    private double height;


    public GirlFriends() {
    }

    public GirlFriends(String name, int age, double height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    /**
     * 获取
     * @return height
     */
    public double getHeight() {
        return height;
    }

    /**
     * 设置
     * @param height
     */
    public void setHeight(double height) {
        this.height = height;
    }

    public String toString() {
        return "GirlFriends{name = " + name + ", age = " + age + ", height = " + height + "}";
    }
}

实现类：

import java.util.Arrays;
import java.util.Comparator;

public class Com {
    public static void main(String[] args) {
        GirlFriends gf1 = new GirlFriends("xiaohong", 18, 1.65);
        GirlFriends gf2 = new GirlFriends("xiaoming", 18, 1.66);
        GirlFriends gf3 = new GirlFriends("xiaowang", 20, 1.67);
        GirlFriends[] arr = {gf1, gf2, gf3};

        //按照年龄身高
        Arrays.sort(arr, new Comparator<GirlFriends>() {
            @Override
            public int compare(GirlFriends o1, GirlFriends o2) {
                double i = o1.getAge() - o2.getAge();
                i = i == 0 ? o1.getHeight() - o2.getHeight() : i;
                i = i == 0 ? o1.getName().compareTo(o2.getName()) : i;
                if (i > 0) {
                    return 1;
                } else if (i < 0) {
                    return -1;

                } else
                    return 0;
            }
        });
        System.out.println(Arrays.toString(arr));
    }
}

12 lambda表达式

使用规则：

注意点：

省略规则

具体的实现举例：

import java.util.Arrays;
import java.util.Comparator;

public class Arr {
    public static void main(String[] args) {

        Integer[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        //使用匿名内部类的完整形式
        Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        //lambda的简单形式
        Arrays.sort(arr, (Integer o1, Integer o2)-> {
                return o2 - o1;
            }
        );
        //lambda表达式的最简形式，需要方法体就一行
        Arrays.sort(arr, (o1, o2) -> o2 - o1);
        System.out.println(Arrays.toString(arr));
    }
}

13 Math类

java.util.math;里面有大量的静态方法，完成与数学相关的方法。

1.abs绝对值

public class an7 {
    public static void main(String[] args) {
            int axNum = -23;
            
            int axNUM = Math.abs(axNum);
            
            System.out.println(axNUM + " " + axNum);
    }
}

运行结果：

2.ceil向上取整

public class an7 {
    public static void main(String[] args) {
            double axNum = -23.2;

            double ayNum = 23.2;

            double axNUM = Math.ceil(axNum);
            double ayNUM = Math.ceil(ayNum);

            System.out.println(axNUM + " " + axNum);
            System.out.println(ayNUM + " " + ayNum);
    }
}

运行结果：

3.floor向下取整

public class an7 {
    public static void main(String[] args) {
            double axNum = -23.2;

            double ayNum = 23.2;

            double axNUM = Math.floor(axNum);
            double ayNUM = Math.floor(ayNum);

            System.out.println(axNUM + " " + axNum);
            System.out.println(ayNUM + " " + ayNum);
    }
}

运行结果：

4.round四舍五入

public class an7 {
    public static void main(String[] args) {
            double axNum = 23.5;

            double ayNum = 23.2;

            double axNUM = Math.round(axNum);
            double ayNUM = Math.round(ayNum);

            System.out.println(axNUM + " " + axNum);
            System.out.println(ayNUM + " " + ayNum);
    }
}

运行结果：

5.max/min最大最小

        int aum=10;
        int bum = 100;
        int Maxum = Math.max(aum,bum);
        int Minum = Math.min(aum,bum);
        System.out.println(Maxum+"\n"+Minum);

执行结果：

14 Scanner类

1.导入包：

java.util包中的Scanner

import java.util.Scanner;

2.创建对象：eg:myObj

Scanner 变量名 = new Scanner(System.in);

如下：创建一个myObj 对象。

Scanner myObj = new Scanner(System.in);

3.调用对象：

基本数据类型标识符 = 变量名.next基本数据类型（）;

eg1.传入应该byte类型的参数---anxian1

import java.util.Scanner;

public class an3 {
    public static void main(String[] args) {

        System.out.println("输入应该数字：");

        Scanner myObj = new Scanner(System.in);

        //传入byte数据类型类型----anXian1

        byte anXian1 = myObj.nextByte();

        System.out.println("anXian1    \n" + anXian1);

    }
}

完整代码如下：

import java.util.Scanner;

public class an3 {
    public static void main(String[] args) {

        System.out.println("输入应该数字：");

        Scanner myObj = new Scanner(System.in);


        byte anXian1 = myObj.nextByte();

        short anXian2 = myObj.nextShort();

        int anXian3 = myObj.nextInt();

        long anXian4 = myObj.nextLong();

        float anXian5 = myObj.nextFloat();

        double anXian6 = myObj.nextDouble();

        String anXian7 = myObj.next();

        System.out.println("anXian1\t" + anXian1 +"\t"+ "anXian2\t"
                + anXian2+"\t"+"anXian3\t" + anXian3+"\t"+"anXian4\t" + anXian4+"\t"+"anXian5\t"
                + anXian5+"\t"+"anXian6\t" + anXian6+"\t"+"anXian7\t" + anXian7);
    }
}

执行结果：

补充：

15 Random类

含参/不含参

import java.util.Random;

public class ax1 {
    public static void main(String[] args){
        Random rand = new Random();
        int x = rand.nextInt(100);//范围0-99
        
        int y = rand.nextInt();//范围-21亿-21左右
    }
}

猜数字游戏

import java.util.Random;
import java.util.Scanner;

public class an1{
    public static void main(String[] args){
        //经典-猜数字游戏
        System.out.println("输入一个数字");

        Random rand = new Random();

        int num =rand.nextInt(5);

        Scanner input = new Scanner(System.in);
        
        for (int i = 1; i <= 5; i++){
            int nums = input.nextInt();
            if (nums == num)
            {
                System.out.println("猜对了");
                break;
            }
            else 
                if (i!=5)
                    continue;
                else
                    System.out.println("游戏结束");
        }
    }

}

16 StringBuffer类与String类

具体的方法

构造方法

StringBuffer()：构造一个没有字符的字符串缓冲区，初始容量为16字符；
StringBuffer(String str)：构造一个初始化为指定内容的字符串缓冲区；
StringBuffer(int capacity)：构造一个没有字符的字符串缓冲区和指定的初始容量；

1 使用StringBuffer创建对象

StringBuffer ist = new StringBuffer();

2 append添加

ist.append(1);
ist.append(2);
ist.append(3);
ist.append(44);
ist.append(4);
ist.append(51);
ist.append(6);

3 delete删除

ist.delete(0,4);//删除索引区间左闭右开
ist.deleteCharAt(ist.length()-1);//删除某个字符_索引位置

4 reverse倒置

ist.reverse();//倒置

5 charAt提取字符

char c = ist.charAt(1);//提取字符_索引位置

6 replace区间字符替换

ist.replace(0,1,"*");//某个区间内的字符进行替换

7 substring提取字符串

String s = ist.substring(1,4);
String  s_ = ist.substring(2);//提取字符串如果单个索引是将末索引省去（2--1）

8 insert插入字符串

ist.insert(2,"an");//索引位置插入字符串

9 toString 变成字符串

String str = ist.toString();

8 Map类

1map集合是一个双列集合

2 key与value的数据类型可以相同也可以不同

3 key不允许重复，value允许重复

4 key与value是一一对应的

二 Collections

集合分类：

集合的常见用法：

注意：这里的contain底层是obj的equals方法比较的是地址值，如果想要比较具体内容，需要在javabean类中重写equals方法。

Collections的三种遍历方式：

迭代器遍历：（迭代器遍历完成，指针不会复位）

import java.util.ArrayList;
import java.util.Iterator;

public class Com {
    public static void main(String[] args) {
        ArrayList<Integer> it = new ArrayList<>();
        it.add(1);
        it.add(2);
        it.add(3);
        it.add(3);
        it.add(3);
        it.add(3);
        Iterator<Integer> co = it.iterator();
        while (co.hasNext()) {
            int num = co.next();
            System.out.println(num);
        }
    }
}

增强for

import java.util.ArrayList;

public class Com {
    public static void main(String[] args) {
        ArrayList<Integer> it = new ArrayList<>();
        it.add(1);
        it.add(2);
        it.add(3);
        it.add(3);
        it.add(3);
        it.add(3);
        for (int num : it) {
            System.out.println(num);
        }
    }
}

lambda表达式：

import java.util.ArrayList;
import java.util.function.Consumer;

public class Com {
    public static void main(String[] args) {
        ArrayList<Integer> it = new ArrayList<>();
        it.add(1);
        it.add(2);
        it.add(3);
        it.add(3);
        it.add(3);
        it.add(3);
        it.forEach(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                System.out.println(integer);
            }
        });

        it.forEach(s->System.out.println(s));
    }
}

LIst:

遍历方式：

基础for循环：（可以使用迭代器的方法进行更改元素）

import java.util.ArrayList;

public class Com {
    public static void main(String[] args) {
        ArrayList<Integer> it = new ArrayList<>();
        it.add(1);
        it.add(2);
        it.add(3);
        it.add(3);
        it.add(3);
        it.add(3);
        for (int i = 0; i < it.size(); i++) {
            System.out.println(it.get(i));
        }
    }
}

1 ArrayList类

数组的长度不可发生改变

但是ArraryList集合的长度可以发生改变

对于ArrayList 有一个<E>这个里面放的东西只能是引用数据类型(String,Integer,Short....)，不能是基本数据类型（byte,short,char,int,long,float,double,boolean）

包装类与String

        ArrayList<Integer> list1 = new ArrayList<>();
        ArrayList<Short> list2 = new ArrayList<>();
        ArrayList<Byte> list3 = new ArrayList<>();
        ArrayList<Character> list4 = new ArrayList<>();
        ArrayList<Long> list5 = new ArrayList<>();
        ArrayList<Float> list6 = new ArrayList<>();
        ArrayList<Double> list7 = new ArrayList<>();
        ArrayList<Boolean> list8 = new ArrayList<>();
        ArrayList<String> list9 = new ArrayList<>();

1 创建对象list

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

2 添加add

//添加
list.add("A");
list.add("B");
list.add("C");

3 删除remove

//删除
list.remove(1);

4 输出

//输出
list.forEach(System.out::println);
System.out.println(list);

5 长度size

//长度
int len = list.size();

6 提取get

//提取
String aa = list.get(1);

7 排序sort

import java.util.ArrayList;
public class ax4 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(11);
        list.add(21);
        list.add(13);
        list.add(41);
        list.forEach(System.out::println);
        System.out.println(list);
        list.sort(Integer::compareTo);
        System.out.println(list);
    }
}

执行结果：

8 倒序输出

使用collections

Collections.sort(list, Collections.reverseOrder());

9 更改元素

第一个空是索引，第二个是要改成的元素。

list.set(2,6);

10 将一个数组变成一个ArrayList类创建的对象

11 截取部分元素

ArrayList<Integer> list2 = new ArrayList<>(list.subList(0,2));

System.out.println(list2);

二 LinkedList

小安同学iter

关注

10
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录