常用java APl

已于 2023-05-23 09:10:32 修改
阅读量170 收藏 1
点赞数 1
文章标签： java
于 2023-05-10 11:11:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64733206/article/details/130491098
版权

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

构造方法说明
public string（）创建空白字符串，不含任何内容
public string（string original）根据传入字符串，创建字符串对象
public string（char[] chs）根据字符数组创建字符串对象
public string（byte[] chs）根据字节数组，创建字符串对象
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
        
    }
}

string s1=“abc”;
string s2=“abs”;
当我们使用双引号直接赋值，系统就会检查字符串是否在串池出现，不存在就创建新的
在这里插入图片描述
引用类型：
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

方法属性
boolean equals方法(要比较字符串)完全一样结果才是true
boolean equalslgnoreCase(要比较字符串))忽略大小写
在这里插入图片描述

案例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("失败");
        }
    }
}

遍历字符串

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

拼接字符串：

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

方法：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);
    }
}

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

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

成员方法；

方法名说明
public StringBuild append（任意类型）添加数据，并返回对象本身
public StringBuilder reverse（）反转容器里面的内容
public int length（）返回长度
public String toString（）通过toString’（）就可以实现把StringBuild转换为String
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);
   

    }
}

在这里插入图片描述

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

在这里插入图片描述
链式编程

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

利用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");
       }
    }
}

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

方法名说明
public StringJoiner（间隔符号）创建一个StringJoiner对象，指定拼接的间隔符号
public StringJoiner（间隔符号，开始符号，结束符号）创建一个StringJoiner对象，指定拼接时的间隔符号，开始符号，结束符号

成员方法：

方法名说明
public StringJoiner add（添加的内容）添加数据，并返回对象本身
public int length（）返回长度
public String toString（）返回一个字符串
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：字符串储存的内存原理；
直接赋值会复用字符串池中的。
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);
    }
方法名说明
boolean add(E e)添加元素，返回值表示是否添加成功
boolean remove(E e)删除指定元素，返回值表示是否删除成功
E remove（int index）删除指定索引的元素，返回被删除的元素
E set（int index，E e）修改指定索引的元素，返回原来的元素
E get（int index）获取指定索引的元素
int size()集合的长度
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);
        }
    }

案例：

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

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：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.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());
        }
    }
}

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

案例：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;
    }
}

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

案例：学生管理系统：

Math:里面

方法都是静态的

方法名说明
public static int abs（int a）获取参数绝对值
public static double ceil（double a）向上取整
public static double floor（double a）向下取整
public static int round（float a）四舍五入
public static int max（int a，int b）获取最大值
public static double pow（double a，double b）返回a的b次幂
public static double random返回值为double的随机值，范围[0.0,1.0)
public static double sqrt（double a）返回a的平方根
public static double cbrt（double a）返回a的立方根
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());
    }
}

abs的输出:66
ceil的输出:4.0
floor的输出:3.0
round的输出:4.0
max的输出:5.6
pow的输出:9.0
0.38015358435326185

System：

方法名说明
public static void exit（int status）终止当前运行的java虚拟机
public static long currentTiMillis（）返回当前系统的时间毫秒值形式
public static void arraycopy（数据源数组，起始索引，目的地数组，起始索引，拷贝个数）数组拷贝
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);
                
    }
}

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

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


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方法
//        再重写方法中把对象属性值进行拼接

    }
}


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
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
javaApl开发文档
02-28
该APL中包含java中各种的APL文档，并且还有javaScript、w3school等APL
java api文档
05-13
jdk8 的api文档，涵盖了jdk8的所有api函数类和接口方法
Java中常用的API
peng的博客
01-30 4767
String、StringBuffer、StringBuilder、Number、Radom、Math、System、包装类Arrays、Collections这些类有很多常用的API，还有日期时间的API，下面我将总结一些常用的API。
javaApI(Application Programming Interface)应用程序编程接口
最新发布
2302_77125952的博客
02-25 1218
重写compareTo方法我们一个类进行排序，那么这个类必须实现Compaareable接口，指定一个排序方式（这样所有的类都使用统一的方法进行排序了） 用来指定排序规则， 可以执行用类中那个属性作为排序的项这个方法在sort（）方法底层使用@Override。
Java基础常见API总结
qq_62717022的博客
01-10 926
特殊情况：* | ：^ . \ 这些符号须在前面加上转义字符\ \加以转义。：在编译时 具体类型可以是object的父类 子类 自身类、接口。String str=“武汉市,孝感市,长沙市,北京市”;该方法会将字符串按照某个字符分割字符串，最终返回数组类型。cat 不是 Dog类型 无法强转。但是在执行时 子类会报错。
JAVA常用API
热门推荐
tuoniaoxs的博客
06-06 1万+
Java常用API String、StringBuilder、Math、System、Object、Objects、BigDecimal等
6.1 理解API的概念
新的起点
07-07 658
Java API通过支持平台无关性和安全性，使得Java适应于网络应用。Java API是运行库的集合，它提供了一套访问主机系统资源的标准方法。　　  运行Java程序时，虚拟机装载程序的class文件所使用的Java API class文件。所有被装载的class文件(包括从应
常用芯片数据手册-APL.zip
09-01
常用芯片数据手册-APL
ReduceMap:Java中的MapReduce
05-10
Java中的MapReduce 介绍 Java中的MapReduce，具有基本的master和worker实现。 项目结构 RPC框架 使用作为RPC框架。 protobuf3文件： master.proto：定义主RPC方法，由工作人员调用。 worker.proto：定义工作程序...
JAVA5.0API
03-14
提供详细的API信息，方便java初学者学习
javaAPI 中文版本CHM文件
03-18
作者手记：我看到许多论坛的朋友， 寻找 中文的javaAPI， 无奈sun没有提供中文的，这是SUN对中国程序员的轻视,有日文,为什么不能有中文,小日本为什么不用看英文。 我利用JavaWebStudio里提供的， 制作chm格式的， 希望对大家学习java提供方便。 Orient Software Company cmh制作者 碧海蓝天
jdk 1.8 APl 的
10-29
2.0的安装包
java String类常用的Apl
m0_62571837的博客
02-27 323
public class Lil5_1 { public static void main(String[] args) { //1.获取字符的长度 apl是length() String name ="我爱你中国"; System.out.println(name.length()); //2 获取某个索引的字符 apl是charAt() char c = name.charAt(1); Sys.
Java API
南辞的博客
11-02 1982
常用的Java API
java API
weixin_46048259的博客
04-09 1743
目录 一、API文档 1.JDK API API 常用包 2.文档注释规范 二、常用类 一、String类 1.String对象不能改变 2.String常量池 3.构造方法 4.常用方法 5.作业 6.案例 一、API文档 1.JDK API 什么是JDK API? Application Programming Interface 应用程序接口 已经写好的，可供直接调用的类。 比如: 字符串操作、IO流、集合操作、线程、网络编程Socket等等
java中的API
钱辉
12-05 792
java中的API
Java API文档
CodeHealer的博客
08-31 1万+
Java API文档
JAVA常用API的笔记
今天也要AC呀！！！
03-15 1092
常用API 1.定义： 指的就是 JDK 中提供的各种功能的 Java类，这些类将底层的实现封装了起来 2.String String 类代表字符串，Java 程序中的所有字符串文字（例如“abc”）都被实现为此类的实例。也就是说，Java 程序 中所有的双引号字符串，都是 String 类的对象。String 类在 java.lang 包下，所以使用的时候不需要导包！ 3.构造字符串的两种方式 通过构造方法创建 通过 new 创建的字符串对象，每一次 new 都会申请一个内存空间，虽然内容相同，但是地址值
javaapl帮助文档
11-16
Java API帮助文档是Java语言的完整说明，它提供了Java中的各种技术的详细资料，以及JDK中提供的各种类的帮助说明。Java API帮助文档是Java开发者经常查阅的资料，可以帮助开发者查看JDK提供的类的信息，包括类的方法...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值