常用java APl

string：字符串内容是不会发生变化的，它的对象在创建后不能被更改。
创建字符串对象：
1：直接赋值：string str=“hghg”；
2：

package com.cn.co;

import java.sql.SQLOutput;

public class Test {
    public static void main(String[] args) {
//        1:
        String s1="abs";
//        2:
        String s2=new String();//空字符串
//        3:
        String s3=new String("jhjhj");
//        4:
        char[] ch={'a','b','c'};
        String s4=new String(ch);//abc
//        5:
        byte[]by={97,98,99};
        //通过阿斯克码转换
        String s5=new String(by);//abs
        
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

string s1=“abc”;
string s2=“abs”;
当我们使用双引号直接赋值，系统就会检查字符串是否在串池出现，不存在就创建新的

引用类型：

案例1：用户登录

package com.cn.co;

import java.sql.SQLOutput;
import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
       String str1="zhangsan";
       String str2="123456";
//       模拟用户输入
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入用户名");
        String username=sc.next();
        System.out.println("请输入密码");
        String password=sc.next();
        
//        判断是否正确
        if(username.equals(str1)&&password.equals(str2))
        {
            System.out.println("用户成功");
        }
        else{
            System.out.println("失败");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

遍历字符串

package com.cn.co;

import java.sql.SQLOutput;
import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        String str="kugdakugvd";
        String str1=new String("wjhdbjhedb");
        for(int i=0;i<str.length();i++)
        {
//            i表示字符串的每一个索引
            char s=str.charAt(i);
            System.out.print(s);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

拼接字符串：

package com.cn.co;

import java.sql.SQLOutput;
import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
     int arr[]={1,2,3};
     String s=arrtostring(arr);
     System.out.println(s);
    }
    public static String arrtostring(int []arr)//接收一个数组
    {
        if(arr==null)
        {
            return "";
        }
        if(arr.length==0)
        {
            return "[]";
        }
        String result="";
        for (int i=0;i< arr.length;i++)
        {
           result= result+arr[i];
        }
        return  result;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

方法：string substring（int beginindex，int endIndex）截取字符串
包头不包尾，包尾不包头
string substring（int beginIndex）截取到末尾
案例：手机号屏蔽：

public class Test {
    public static void main(String[] args) {
    String phone="2873681746";
    String s=phone.substring(0,3);
    String str=phone.substring(7);
    System.out.println(s+"******"+str);
    }
}
1
2
3
4
5
6
7
8

StringBuilder：
可以看成一个容器，创建以后里面内容是可变的：提高字符串的操作效率
，创建以后里面的内容是可以变化的。
StringBuilder的构造方法

成员方法；

public class Test {
    public static void main(String[] args) {
   StringBuffer sb=new StringBuffer("abc");
//   添加元素
   sb.append(1);
   sb.append(2.3);
   sb.append(true);
//   反转字符串
   sb.reverse();
//   获取长度
        int len=sb.length();
        System.out.println(len);
   System.out.println(sb);
   

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public class Test {
    public static void main(String[] args) {
   StringBuffer sb=new StringBuffer("abc");
//   添加字符串
        sb.append("aaa");
        sb.append("nnn");
//        把StringBuffer变回字符串
        String str= sb.toString();
        System.out.println(str);
    }
}
1
2
3
4
5
6
7
8
9
10
11

链式编程

public class Test {
    public static void main(String[] args) {
//   链式编程 当我们在调用一个方法的时候 不需要用变量接受它的值，可以继续调用其他方法
        StringBuffer sb=new StringBuffer();
        sb.append("aaa").append("bbb").append("ccc");//链式编程
        System.out.println(sb);
        String str=sb.toString();
        System.out.println(str);
    }
}
1
2
3
4
5
6
7
8
9
10

利用StringBuffer()做题：例子判断字符串是否为对称字符串

public class Test {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String str= sc.next();
//        把字符串转换为StringBuffer()类型
//        StringBuffer sb=new StringBuffer();
//        sb.append(str);
//        sb.reverse();
        //String st=sb.toString();
//        if(st.equals(str))
//        {
//            System.out.println("yes");
//        }
        String sb=new StringBuffer().append(str).reverse().toString();
        if(sb.equals(str))
     {
         System.out.println("yes");
       }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

StringJoiner：
StringJoiner和StringBuilder一样可以看成一个容器，创建以后里面内容可以换。
作用：提高字符串的操作效率，而且代码编写讲解。
构造方法：

成员方法：

public class Test {
    public static void main(String[] args) {
        StringJoiner sj=new StringJoiner("---");
//        添加元素
        sj.add("aaa").add("bbn").add("jjj");
//        打印结果
        System.out.println(sj);//输出结果aaa---bbn---jjj
    }
}
1
2
3
4
5
6
7
8
9

字符串原理：
1：字符串储存的内存原理；
直接赋值会复用字符串池中的。
new出来的不会复用，而是开辟一个新的空间
2：==号比较的是什么
基本数据类型比较的是数据值
引用数据类型比较的是地址值

集合：长度可变的容器，自动扩容。不能直接存基本数据类型。
数组长度固定，集合长度可变，数组可以存基本数据类型引用数据类型，集合只能存引用数据类型，如果要存基本数据类型要把其包装类。
基本数据类型的包装类：
byte ->Byte
short->Short
char->Character
int->Integer
long->Long
float->Float
double->Double
boolean->Boolean

public class Test {
    public static void main(String[] args) {
//       1：创建集合对象
//        2:泛型：限定集合中存储数据的类型
//        此时我们创建的是ArryList的对象，而ArrarList是java已经写好的一个类
//        这个类在底层做了一些处理
//        打印对象不是地址值，而是集合中存储数据内容
//        在展示时会把[]把所有的数据进行包裹
        ArrayList<String> list=new ArrayList<String>();
        System.out.println(list);
    }

1
2
3
4
5
6
7
8
9
10
11
12

public class Test {
    public static void main(String[] args) {
//       1：创建集合对象
//        2:泛型：限定集合中存储数据的类型
//        此时我们创建的是ArryList的对象，而ArrarList是java已经写好的一个类
//        这个类在底层做了一些处理
//        打印对象不是地址值，而是集合中存储数据内容
//        在展示时会把[]把所有的数据进行包裹
        ArrayList<String> list=new ArrayList<String>();
//       1: 添加元素
        list.add("jsdnhdsbjedb");
        list.add("kkkkk");
        list.add("aaa");
//        删除元素,返回是否删除成功
        boolean f=list.remove("aaa");//true
        System.out.println(f);
//        删除指定索引的元素，返回被删除的元素
//        String str1=list.remove(1);//aaa
//        System.out.println(str1);
//        修改指定索引元素,返回指定索引上原来元素
        String result=list.set(0,"ddd");
        System.out.println(result);//jsdnhdsbjedb
        System.out.println(list);//[ddd,kkkkk,aaa]
//        查询指定索引上元素
        String s=list.get(0);
        System.out.println(s);//ddd
//        遍历
        for(int i=0;i< list.size();i++)
        {
            String p=list.get(i);
            System.out.println(p);
        }
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

案例：

 public static void main(String[] args) {

//        需求：定义一个集合，添加数字，并进行遍历，遍历格式参照：[元素1,元素2，元素3]
//        1：创建集合
        ArrayList<Integer> list=new ArrayList<>();
//        2:添加元素
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
//        3:遍历
        System.out.println(list);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

public static void main(String[] args) {

//        需求：定义一个集合，添加字符，并进行遍历，遍历格式参照：[元素1,元素2，元素3]
//        1：创建集合
        ArrayList<Character> list=new ArrayList<>();
//        2:添加元素
        list.add('a');
        list.add('b');
        list.add('c');
        list.add('d');
//        3:遍历
        System.out.println(list);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

案例
1：test和stu在一个包里

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

//        需求：定义一个集合，添加学生对象，并进行遍历学生类属性为：姓名，年龄
//        1：创建集合
        ArrayList<stu> list=new ArrayList<>();
//        创建学生对象
        stu s1=new stu("zhansan",18);
        stu s2=new stu("lisan",19);
        stu s3=new stu("tq",18);
//        2:添加元素
        list.add(s1);
        list.add(s2);
        list.add(s3);
//        3:遍历
        for(int i=0;i<list.size();i++)
        {
            stu s=list.get(i);
            System.out.println(s.getName()+","+s.getAge());
        }
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

1.1

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

//        需求：定义一个集合，添加学生对象，并进行遍历学生类属性为：姓名，年龄
//        1：创建集合
        ArrayList<stu> list=new ArrayList<>();
//        创建学生对象,加入集合
        Scanner sc=new Scanner(System.in);
        for(int i=0;i<3;i++)
        {
            stu s=new stu();
            System.out.println("请输入学生名字");
            String name=sc.next();
            System.out.println("请输入年龄");
            int age=sc.nextInt();
//            把name和age赋值给学生对象
            s.setName(name);
            s.setAge(age);
//            加入集合
            list.add(s);
        }

//        3:遍历
        for(int i=0;i<list.size();i++)
        {
            stu s=list.get(i);
            System.out.println(s.getName()+","+s.getAge());
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

2：

public class stu {
//    1:私有化成员变量
//    空参构造方法
//    带全部参数的构造函数
//    get、set方法
    private String name;
    private int age;

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

    public stu() {
    }

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


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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

案例：Main和phone在一个包

//筛选价格小于3000的手机信息
public class Main {
    public static void main(String[] args) {
        ArrayList<phone>list=new ArrayList<>();
        //ArrayList<phone>li=new ArrayList<>();
        phone u1=new phone("小米",1000);
        phone u2=new phone("华为",8000);
        phone u3=new phone("苹果",9000);
//        添加到集合
        list.add(u1);
        list.add(u2);
        list.add(u3);
        chazhao(list);
        
    }
    public static void chazhao(ArrayList<phone>list)
    {
        for (int i=0;i< list.size();i++)
        {
            phone p=list.get(i);
            int price=p.getJg();
            if(price<3000)
            {
                //li.add(p);
                System.out.println(p.getJg()+","+p.getPp());
            }
        }
        //return li;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

public class phone {
    private String pp;
    private int jg;
    phone(){

    }
    phone(String pp,int jg)
    {
        this.pp=pp;
        this.jg=jg;
    }

    public String getPp() {
        return pp;
    }

    public void setPp(String pp) {
        this.pp = pp;
    }

    public int getJg() {
        return jg;
    }

    public void setJg(int jg) {
        this.jg = jg;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

案例：学生管理系统：

Math:里面

方法都是静态的

package com.cn.co;

import java.sql.SQLOutput;

public class Test {
    public static void main(String[] args) {
//        abs获取参数绝对值
        int a=Math.abs(-66);
        System.out.println("abs的输出:"+a);
//        ceil向上取整(正负值都可,向上往大取)
        double b=  Math.ceil(3.4);
        System.out.println("ceil的输出:"+b);
//        floor向下取整(正负值都可,向下往小取)
        double c=Math.floor(3.4);
        System.out.println("floor的输出:"+c);
//        round四舍五入
        double d=Math.round(4.4);
        System.out.println("round的输出:"+d);
//        max获取两个整数最大值
        double max=Math.max(3.1,5.6);
        System.out.println("max的输出:"+max);
//        pow获取a的b次幂
        double u=Math.pow(3,2);
        System.out.println("pow的输出:"+u);
//        random返回随机值
        System.out.println(Math.random());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

abs的输出:66
ceil的输出:4.0
floor的输出:3.0
round的输出:4.0
max的输出:5.6
pow的输出:9.0
0.38015358435326185
1
2
3
4
5
6
7

System：

package com.cn.co;

import java.sql.SQLOutput;

public class Test {
    public static void main(String[] args) {
//        方法的形参：
//   1:     状态码：
//        0：表示当前虚拟机是正常停止
//        非0：表示当前虚拟机是异常停止
        //System.exit(0);
//        下面代码都不会执行了
        //System.out.println("看看我停止了吗");
//2:返回从时间原点开始到现在时间毫秒数
        long l=System.currentTimeMillis();
        System.out.println(l);
//        3:arraycopy数组拷贝，如果两个都是基本数据类型两个数组类型应该一样，
//        两个都是引用数据类型，则可以子类型赋给父类型
        int a[]={1,2,3,4,5,6,7,8,9,10};
        int[]arr2=new int[10];
//        把arr1里面数据拷贝到arr2
//        参数1：要拷贝的数据从哪个数组里面来，
//        参数2：从数据源数组第几个索引开始拷贝，
//        参数3：目的地，要把参数拷到哪个数组
//        参数4：目的地数组的索引
//        参数5：拷贝数据数
        System.arraycopy(arr1,0,arr2,0,10);
                
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

runtime：当前虚拟机运行环境
里面方法不是静态的。

package com.we.wd;

public class runtime {
    public static void main(String[] args) {
        //public static RunTime 当前系统的运行环境对象
        //public void exit（int status）   停止虚拟机
        //public int availbleProcessors 获取cpu的线程数


//        1：获取runtime对象
        Runtime ri=Runtime.getRuntime();
        Runtime r2=Runtime.getRuntime();
//        2:停止虚拟机
        //ri.exit(1);
        System.out.println("看看我执行了吗");

//        3:获取cpu的线程数
        System.out.println(ri.availableProcessors());
//        4:总内存大小
        System.out.println(ri.maxMemory());
//        5:已经获取的内存大小
        System.out.println(ri.totalMemory());
//        6:剩余空间大小
        System.out.println(ri.freeMemory());
//        7：运行cmd命令
        System.out.println(ri.exec("notepad" ));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

object：object是java中的顶级父类，所有的类都直接或者间接的继承于object类。
object类中方法可以被所有子类访问，所以我们要学习object类和里面方法。
object里面只有无参构造函数

package com.ww.wen;

import java.util.Objects;

public class Student {
    private String name;
    private int age;

    public Student() {
    }

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

    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;
    }


//    toString方法的重写


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

    @Override
    //这里重写方法比较的是对象内部的属性值
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

package com.ww.wen;

public class objecto {
    public static void main(String[] args) {
        Object obj=new Object();
        String str=obj.toString();
        System.out.println(str);//java.lang.Object@1b6d3586
//        细节
        //System：类名
        //out；静态变量
        //System.out:获取打印的对象
        //println：方法
        //参数：要打印的内容
        //当我们打印一个对象的时候，底层就会调用对象的toString方法，把对象变成字符串，然后
        //打印早控制台
        //默认情况下，因为Object类中toString方法返回的是地址值。所以默认情况我们打印一个对象打印的是地址值
        //我们要看对象内部属性值应该怎么办：重写父类中的方法
        Student stu=new Student("lisi",19);
        String str2=stu.toString();
        System.out.println(str2);//lisi,19
//        toString结论
//        如果我们要打印应该对象，想要看到它的属性值的话，那么就重写toString方法
//        再重写方法中把对象属性值进行拼接

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

package com.ww.wen;

public class objecto {
    public static void main(String[] args) {
        Object obj=new Object();
        String str=obj.toString();
        System.out.println(str);//java.lang.Object@1b6d3586
//        细节
        //System：类名
        //out；静态变量
        //System.out:获取打印的对象
        //println：方法
        //参数：要打印的内容
        //当我们打印一个对象的时候，底层就会调用对象的toString方法，把对象变成字符串，然后
        //打印早控制台
        //默认情况下，因为Object类中toString方法返回的是地址值。所以默认情况我们打印一个对象打印的是地址值
        //我们要看对象内部属性值应该怎么办：重写父类中的方法
        Student stu=new Student("lisi",19);
        String str2=stu.toString();
        System.out.println(str2);//lisi,19
//        toString结论
//        如果我们要打印应该对象，想要看到它的属性值的话，那么就重写toString方法
//        再重写方法中把对象属性值进行拼接

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27