Java API

最新推荐文章于 2022-03-29 17:47:45 发布
最新推荐文章于 2022-03-29 17:47:45 发布
阅读量216 收藏
点赞数
分类专栏： java 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/mood0916/article/details/121581763
版权
本文详细介绍了Java API中的核心类，包括Object的toString()和equals()方法，Arrays类的equals()、sort()、binarySearch()及复制方法，以及String类的相关功能。还探讨了线程安全的StringBuffer和StringBuilder的区别与使用场景。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

目录

API

Object类

toString()

equals()

Arrays类

equals()方法

sort(排序)

binarySearch（二分法/折半查找）

数组复制（拷贝）

toString() 方法

String 类

构造方法

判断功能

获取功能

转换功能

替换功能

去除字符串两空格

StringBuffer

构造方法

添加功能

替换功能

删除功能

反转功能

截取功能

StringBuilder

String ，StringBuffer 和 StringBuilder的比较

附加

API

API ： java语言中实际提供的类和接口

API 文档：对Java中提供的类和接口中的功能进行说明的文档。

Object类

Object类是所有Java类的祖先（根基类）。每个类都使用 Object 作为 超类（父类）。所有对象（包括数组）都实现这个类的方法。

所有类直接间接继承Object ,为实现多态性.

如果在类的声明中未使用extends关键字指明其基类，则默认基类为 Object类

public class Person { }

等价于： public class Person extends Object { }

toString()

Object类中定义有public String toString()方法，其返回值是 String 类型，描述当前对象的有关信息。

 String toString() 返回对象的字符串表示形式。

 native:

         修饰的方法称为本地方法(有些方法java是不实现的,直接调用本地操作系统中的方法)
输出一个对象时,默认回调用类中toString(), 我们的类中如果没有定义toString(),找父类中的toString()。
    Object类中的toString()方法：

public String toString() {
              getClass().getName()+"@" hashCode();---------------> 转成16进制的字符串
 }
（1）没有进行toString()方法重写.

public class Car extends Object{
    String name;
    int price;
 
    public Car(String name, int price) {
        this.name = name;
        this.price = price;
    }
}
public class JavaApiDemo {
 
   
    public static void main(String[] args) {
        Car car = new Car("宝马", 3000000);
        System.out.println(car);//javaapi.Car@1b6d3586
        System.out.println(car.toString());  //javaapi.Car@1b6d3586
                                
    }
}

（2） 重写toString()方法： 将对象以字符串形式输出

public class Car extends Object{
    String name;
    int price;
 
    public Car(String name, int price) {
        this.name = name;
        this.price = price;
    }
 
    //将对象以字符串形式输出
    @Override
    public String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
 
}
public class JavaApiDemo {
    public static void main(String[] args) {
      Car car = new Car("baoma",100000);
        System.out.println(car); //Car{name='baoma', price=100000}
        System.out.println(car.toString());//Car{name='baoma', price=100000}
     
 
 
      
    }
}

equals()

Object类中的equals()方法：

      public boolean equals(Object obj) {
                return (this == obj);
            }

== （1）用于基本类型比较  比较的值是否相等
       （2） 用于引用类型比较  比较的是引用地址(对象地址)是否相等

 
 
public class Car extends Object{
    String name;
    int price;
 
    public Car(String name, int price) {
        this.name = name;
        this.price = price;
    }
 
    //将对象以字符串形式输出
    @Override
    public String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
    @Override
    public boolean equals(Object obj) {
        if(obj instanceof Car){
            Car car = (Car)obj;
            return this.name.equals(car.name)&&this.price==car.price;
        }
        return false;
    }
 
}
public class ObjectDemo2 {
 
    public static void main(String[] args) {
        int a = 10;
        int b = 10;
        System.out.println(a==b);//true
 
        Car car1 = new Car("bsj",100000);
        Car car2 = new Car("bsj",100000);
        Car car3 = car2;
 
        /*
          car1.equals(car2) 由于Car类中没有重写equlas(),那么调用Object类中的equals()
           public boolean equals(Object obj) {
                return (this == obj);
            } 
         */
        System.out.println(car1.equals(car2));//true car1==car2
        System.out.println(car2.equals(car3));//true   Car car3 = car2;
 
        /*
          字符串类中重写了Object类中的equals()  实现是比较两个字符串中每一个字母是否相等
          所以一般默认为equals() 方比较的是对象中内容是否相等
         */
        String s1 = new String("abc");
        String s2 = new String("abc");
        System.out.println(s1.equals(s2));//true
 
 
    }
}

 System.out.println(s1.equals(s2));

字符串类中重写了Object类中的equals()  实现是比较两个字符串中每一个字母是否相等
所以一般默认为equals() 方比较的是对象中内容是否相等。

源码：

public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    } 


Arrays类

java.util.Arrays类

Arrays类中包含了许多关于数组操作的静态方法

equals()方法

定义： 比较两个非同一数组是否相等，而数组本身的equals判断另一个数组是否它本身。

声明：public static boolean equals(type[]a,type[]a2)

public class ArraysDemo1 {
    public static void main(String[] args) {
        int[] a = {1,2,3};
        int[] b = {1,2,3};
        int[] c = {1,3,5};
        //比较数组中的内容/数据
        System.out.println(Arrays.equals(a,b));//true
        System.out.println(Arrays.equals(a,c));//false
 
      
    }
}

sort(排序)

作用于数组的所有元素 public static void sort(type[] a){}

public class ArraysDemo2 {
    public static void main(String[] args) {
        //sort 排序（底层使用快速排序）
        int[] x = {5,4,3,2,1};
        Arrays.sort(x); //数组a全部数据排序  0~length - 1
        System.out.println(Arrays.toString(x));//[1, 2, 3, 4, 5]
        int[] y = {5,4,3,2,1};
        Arrays.sort(x,0,3);//对某个区间排序，开始位置（包含）,不包含（结束位置）
        //开始位置：fromIndex  结束位置：toIndex
        System.out.println(Arrays.toString(y));//[3, 4, 5, 2, 1]
    }
}

自定义对象排序

自定义类实现Comparable接口,需要重写compareTo方法

 
public class User implements Comparable<User>{
    private String account;
    private String possword;
    private int id;
    public String getAccount() {
        return account;
    }
 
    public void setAccount(String account) {
        this.account = account;
    }
 
    public String getPossword() {
        return possword;
    }
 
    public void setPossword(String possword) {
        this.possword = possword;
    }
 
    public int getId() {
        return id;
    }
 
    public void setId(int id) {
        this.id = id;
    }
 
    public User(String account, String possword, int id) {
        this.account = account;
        this.possword = possword;
        this.id = id;
    }
 
    @Override
    public String toString() {
        return "Test{" +
                "account='" + account + '\'' +
                ", possword='" + possword + '\'' +
                ", id=" + id +
                '}';
    }
    /*
       为我们的引用类型提供一个自定义排序规则,
       方法会在Arrays类中的sort()方法底层调用
       结果是用来判断大小  小于0  等于0  大于0
     */
 
    @Override
    public int compareTo(User o) {
        return this.id - o.id;
        //return this.account.compareTo(o.account);
    }
    
}
import java.util.Arrays;
 
public class Test {
    public static void main(String[] args) {
        User api1 = new User("123456","111111",1);
        User api2 = new User("123457","111111",4);
        User api3 = new User("123458","111111",2);
        User api4 = new User("123459","111111",3);
        User[] users = {api1,api2,api3,api4};
        System.out.println(users);
        //[Ljavaapi.User;@1b6d3586
 
        Arrays.sort(users);
        System.out.println(Arrays.toString(users));
        /*[ApiDemo1{account='123456', possword='111111', id=1}, 
           ApiDemo1{account='123458', possword='111111', id=2}, 
           ApiDemo1{account='123459', possword='111111', id=3}, 
           ApiDemo1{account='123457', possword='111111', id=4}] */
 
    }
}

binarySearch（二分法/折半查找）

前提：有序的

import java.util.Arrays;
public class ArraysDemo3 {
    public static void main(String[] args) {
        //折半查找 前提：有序的
        int[] a = {1,2,3,4,5,6,7,8,9};
        System.out.println(Arrays.binarySearch(a,2,8,7));//6
        System.out.println( Arrays.binarySearch(a,4));//3
        //若返回负数则表示在数组中没有该值
    }
}

数组复制（拷贝）

返回一个新数组，并且将原数组值复制到新数组中。（可以进行扩容）

import java.util.Arrays;
public class ArraysDemo4 {
    public static void main(String[] args) {
 
        //数组复制：
        //传入原数组，新数组长度
    
        int[] b = {1,4,7,3,2};
        int[] c = Arrays.copyOf(b,10);
        System.out.println(Arrays.toString(c));
        //[1, 4, 7, 3, 2, 0, 0, 0, 0, 0]
    }
}

toString() 方法

声明：public static String toString(type[] a){}

返回指定数组内容的字符串表示形式

例：上面所重写的toString()方法

 @Override
    public String toString() {
        return "Test{" +
                "account='" + account + '\'' +
                ", possword='" + possword + '\'' +
                ", id=" + id +
                '}';
    }

String 类

由多个字符组成的一串数据，值一旦创建，不可改变。

private final char value[];

String s = "abc";    底层：char[] c = {'a','b','c'};

          s+= 'def';

          s+= 'gh';

          s+='aaa';

每一步都创建一个新对象。

一旦值改变，就会创建一个新对象。

创建：

（1）简单的创建方式

String s = "abc";

先去字符串常量池中查找，有没有abc，如果没有就在字符串常量中创建一个新的对象（abc），

如果字符串常量中已经存在，那么直接指向已有的对象即可。

（2）new + 构造方法

String s1 = new String();

String s2 = new String();

凡是new出来的对象，在内存空间是独一无二的。
 

public class StringDemo1 {
 
    public static void main(String[] args) {
     
        /*
          String对象的创建方法:
          1.String s = "abc";
          2.String s1 = new String();
         */
 
         
         // 1. 简化的创建方式
            String s = "abc";
            String s1 = "abc";
            System.out.println(s==s1);//true
            System.out.println(s.equals(s1));//true
         
          // 2. new +构造方法
            String s3 = new String("abc");
            String s4 = new String("abc");
            System.out.println(s3==s4); //false
            System.out.println(s3.equals(s4)); //true
    }
}

构造方法

  • public String()
  • public String(String str)
  • public String(byte[] bytes)
  • public String(char[] value) 
     
        构造方法：
         public String() {
            this.value = "".value;
        }
        String("字符串")
         public String(String original) {
            this.value = original.value;
            this.hash = original.hash;
       
        }
        String s1 = "abc";
        String s2 = new String("abc");

    判断功能

  • boolean equals(Object obj)
  • boolean equalsIgnoreCase(String str)
  • boolean contains(String str)
  • boolean isEmpty()
  • boolean startsWith(String prefix)
  • boolean endsWith(String suffix)
public class StringDemo1 {
    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = new String("abc");
        String s3 = new String("abC");
//       判断功能方法：
        //比较字符串内容是否相等
        System.out.println(s1.equals(s2));//true
        //比较字符串内容是否相等（忽略大小写）
        System.out.println(s1.equalsIgnoreCase(s3));//true
//        判断是否包含指定的子串
        System.out.println(s1.contains("c"));//true
//        判断是否为空（""）
        System.out.println(s1.isEmpty());//false
//        判断以指定字符串开头
        System.out.println(s1.startsWith("ab"));//true
//        从指定位置开始，判断以指定字符串开头
        System.out.println(s1.startsWith("ab", 0));//true
//        判断以指定字符串结束
        System.out.println(s1.endsWith("bc"));//true
 
        System.out.println(s1.startsWith("ab", 0));//true
        String s4 = new String("def");
        //字符串比大小
        System.out.println(s1.compareTo(s4));//-3
 
 
    }
}

获取功能

  • int length()
  • char charAt(int index)
  • int indexOf(String str)
  • int indexOf(String str,int fromIndex)
  • String substring(int start)
  • String substring(int start,int end)
public class StringDemo2 {
    public static void main(String[] args) {
        //获取功能
        String s1 = "abcdefgd";
        //           01234567
        System.out.println(s1.length());//8
//        获取指定位置（索引）的字符
        char ch = s1.charAt(4);
        System.out.println(ch);//e
//        从前向后找，只找首次出现的位置
        int index1 = s1.indexOf("d");
        System.out.println(index1);//3
//        从前向后找，从指定位置开始
        int index2 = s1.indexOf("d", index1 + 1);
        System.out.println(index2);//7
//        从后向前查找，首次出现的位置
        int index3 = s1.lastIndexOf("d");
        System.out.println(index3);//7
//        从指定的位置开始截取字符串，直到最后一位，最终返回一个新的字符串对象
        String s2 = s1.substring(3);
        System.out.println(s1);//abcdefgd
        System.out.println(s2);//defgd
 
//        截取指定区间，包含开始位置，不包含结束位置
        String s3 = s1.substring(2,6);
        System.out.println(s3);//cdef
    }
}

转换功能

  • byte[] getBytes()
  • char[] toCharArray()
  • static String valueOf(char[] chs)
  • String toLowerCase()
  • String toUpperCase()
  • String concat(String str)
  • Stirng[] split(分割符);
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
 
public class StringDemo3 {
    public static void main(String[] args) throws UnsupportedEncodingException{
        String s = "你好";//默认为UTF-8编码，其中一个汉字占3个字节
//        编码和解码不一致，导致出现乱码
        byte[] b = new byte[0];
        b = s.getBytes("UTF-8");
        System.out.println(Arrays.toString(b));//[-28, -67, -96, -27, -91, -67]
 
        String s1 = new String(b,"UTF-8");
        System.out.println(s1);//你好
 
        String s2 = new String(b,3,3,"UTF-8");
        System.out.println(s2);//好
 
        String str = "abcdef";
//        将字符串转换为一个新的char数组
        char[] ch = str.toCharArray();
        System.out.println(Arrays.toString(ch));//[a, b, c, d, e, f]
//       将char 数组 转为字符串
        String str1 = new String(ch);
        System.out.println(str1);//abcdef
        String str2 = String.valueOf(ch);
        System.out.println(str2);//abcdef
 
        String str3 = "ABCdefg";
//        转大写
        System.out.println(str3.toUpperCase());//ABCDEFG
//        转小写
        System.out.println(str3.toLowerCase());//abcdefg
        // + 可以连接其他类型
        String str4 = str3.concat("abc");
        System.out.println(str4);//ABCdefgabc
 
//        按照指定的分隔符，将字符串拆分成数组
        String strs = "abc:cdef:fgh";
        String[]  strings = strs.split(":");
        System.out.println(Arrays.toString(strings));//[abc, cdef, fgh]
 
    }
}


替换功能

  • String replace(char old,char new)
  • String replace(String old,String new)
  • replaceAll(String regex, String replacement)
  • replaceFirst(String regex, String replacement)
public class ApiDemo {
    public static void main(String[] args) {
        String s = "abcdefrgcba";
        /*
        target: 连续的字符串
        regex: 规则（正则表达式模式匹配）
         */
        //字符串的替换
        String s1 = s.replace("c", "C");
                              // target 
        System.out.println(s1.replace('a', 'b'));//bbCdefrgCbb
        System.out.println(s1);//abCdefrgCba
        String s2 = "abc12345";
        //替换所有符合规则的字符串
        System.out.println(s2.replaceAll("\\d", "D"));//abcDDDDD
                                          //regex
        String s3 = "abc12345";
        //替换符合规则的第一个字符串
        System.out.println(s3.replaceFirst("\\d", "A"));//abcA2345
    }
}

去除字符串两空格

String trim()

 只能去掉收尾两端的空格，中间的空格不能去掉。

public class ApiDemo {
    public static void main(String[] args) {
        String  s4 = "  abc def   ";
        System.out.println(s4.length());//12
        System.out.println(s4.trim());//abc def
        System.out.println(s4.trim().length());//7
    }
}

StringBuffer

StringBuffer ：线程安全，可变的字符序列。只变底层的char 数组。

char[ ] value   

初始容量默认为16

可变的字符序列： 当向StringBuffer 中添加内容时，是将内容添加到底层的数组中，数组没有被final 修饰，当数组装满是，会创建一个新的数组，将新的数组之地给底层的数组，StringBuffer 对象的地址不会发生改变。
源码：

char[] value;
public synchronized int capacity() {
     return value.length;
}
public StringBuffer(String str) {
      super(str.length() + 16);
      append(str);
}
public StringBuffer() {
      super(16);
}
public StringBuffer(int capacity) {
      super(capacity);
}

构造方法

public StringBuffer() {
      super(16);
}
public StringBuffer(String str) {
      super(str.length() + 16);
      append(str);
}

添加功能

public StringBuffer append(String str)

public StringBuffer insert(int offset,String str)

替换功能

public StringBuffer replace(int start,int end,String str)

删除功能

public StringBuffer deleteCharAt(int index)

public StringBuffer delete(int start,int end)

反转功能

public StringBuffer reverse()

截取功能

public String substring(int start)

public String substring(int start,int end)

package javaapi4;
 
public class ApiDemo2 {
    public static void main(String[] args) {
      //指定StringBuffer的默认值为20;
        StringBuffer stringBuffer1 = new StringBuffer(20);
        /*
        添加功能
         */
        StringBuffer stringBuffer = new StringBuffer("abcd");
        //向末尾添加字符串
        System.out.println(stringBuffer.append(5));// abcd5
        //向指定位置添加字符串
        System.out.println(stringBuffer.insert(2, "xyz"));// abxyzcd5
        /*
        替换功能
         */
        //将指定区域替换成指定字符串
        System.out.println(stringBuffer.replace(1, 3, "ccc"));//acccyzcd5
        /*
        删除功能
         */
        //删除指定位置的字符
        System.out.println(stringBuffer.deleteCharAt(4));// accczcd5
        //删除指定区域的字符串（包含起始位置，不包含结束位置）
        System.out.println(stringBuffer.delete(2, 5));// accd5
        /*
        反转功能
         */
        //将字符串逆序
        System.out.println(stringBuffer.reverse());// 5dcca
        /*
        截取功能
         */
        //从指定位置开始截取字符串
        String s1 = stringBuffer.substring(3);
        System.out.println(s1);//ca
        //截取指定区域字符串，包含开始位置，不包含结束位置
        String s2 = stringBuffer.substring(1,3);
        System.out.println(s2);//dc
        
        //返回是实际存在的数组中的字符个数
        System.out.println(stringBuffer.length());// 返回是实际存在的数组中的字符个数 5
    }
}

StringBuilder

线程不安全，可变的字符序列。

其构造方法与功能与StringBuffer相似。

String ，StringBuffer 和 StringBuilder的比较

 String：     字符序列不可变，底层使用char[ ] 数组实现

                       适用于少量字符串的使用

                        字符串的每次使用都会创建一个新的对象

                         final类，不可别继承

StringBuffer：可变的字符序列，底层使用char[ ] 数组实现

                       适用于大量字符串的使用

                      任何对它指向的字符串的操作都不会产生新的对象

                       适用于多线程下的字符串操作

                       使用同步锁（synchronized）

                        final类，不可别继承

StringBuilder：可变的字符序列，底层使用char[ ] 数组实现

                       适用于大量字符串的使用

                       任何对它指向的字符串的操作都不会产生新的对象

                       适用于单线程的字符串操作

                       final类，不可别继承


附加

线程安全：多个线程对同一资源进行访问时。

同一时间内，有多个线程对同一资源进行访问，可以同时进入多个线程，但是不安全，需要使用同步锁（只允许进入一个）。在同一时间只能有一个线程对同一资源进行访问。（使用StringBuffer）

同一时间内，只有一个线程对同一资源进行访问（使用StringBuilder）
 

java清空byte数组_从字节数组中删除多余的“空白”字符并转换为字符串
weixin_30902943的博客
02-21 4935
我在这里工作了一段时间，在这里没有发现任何关于此的内容，所以我想我会发布我的解决方案来批评/有用。从字节数组中删除多余的“空白”字符并转换为字符串import java.lang.*;public class Concat{public static void main(String[] args){byte[] buf = new byte[256];int lastGoodChar=0;//f...
obs-java-client:OBS Websocket API的Java API
04-05
OBS的Java API 与OBS通信的Java API。 当前支持Java 11+ Websocket客户端和Jackson的 。 消息 版本1.3已发布，并基于obs-websocket协议定义重建了要生成的事件请求。 它还支持OBS v4.9.0中的所有请求。 1.4版旨在...
C# byte数组去除尾部0x00空白区域.
chenhui389的专栏
09-28 8510
网络通信中,经常会有收发数据的缓冲区内没有填充满,字节数组的后半段全是空白\0 符号. 如果收发的是可字符编码的数据,可以对内容进行转字符串,然后去除末尾的\0符号即可,可以直接用字符串进行后续处理. 例如: string recv = Encoding.Default.GetString(bytes); recv = recv.TrimEnd('\0'); 如果收到的不是可字符编码的数据,而是需要特定的方式解码的数据,由于字符集编码不能覆...
java中怎么把string数组转成string
weixin_38914772的博客
10-10 9955
public static void main(String[] args) { //第一种： String [] arr = {“41”,“a”,“5”,“g56”}; String s1 = Arrays.toString(arr); System.err.println(s1);//[41, a, 5, g56] //第二种： String s2 = StringUtils.join(arr...
字符串中空格的坑
weixin_44632065的博客
03-29 1207
空格的类型 编码32的空格，就是我正常输入的中英文空格，数据库里的空格一般也是这个。 网页上的NBSP空格，这是编码格式为-62，-96，感觉应该是和网页上的空格有关，也可能和编码方式有关。 错误记录： 在查询数据库时候，你会发现两个字符串一模一样，但是匹配不到，自然你也就查询不出数据 在字符串使用NBSP空格时候，查询结果 用sql语句查询也是一样的结果， 正常空格的查询结果： 就能够查询出来 问题解决 一开始以为是匹配的语句也错了，但是发现并没有错，就把客户发来的数据拿去数据查询，一查吓一跳
Java代码-3-字符串与数组
My优快云ok的博客
09-21 321
1、长字符串逆序，包含空格： import java.util.Scanner; public class TestString2 { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.println("请输入字符串"); String inputString = scanner.nextLine();
redmine-java-api:Redmine Java API
05-14
Redmine / Chiliproject Java API。 使用Redmine的REST API（不要忘记在Redmine服务器设置中启用它）。 不需要在Redmine / Chiliproject服务器上安装任何插件。 需要JVM 11或更高版本。 支持HTTP代理 支持来自...
JAVAAPI文档
09-13
Java API文档是Java开发者不可或缺的参考资料，它详细记录了Java Development Kit (JDK) 中所有类、接口、方法和常量的信息。这份文档是官方提供的，确保了信息的准确性和完整性，为程序员提供了关于如何使用Java...
ElasticSearch Java API 中文文档
01-04
标题《ElasticSearch Java API 中文文档》表明本篇文档的主要内容是关于ElasticSearch的Java API的中文使用说明和相关知识点介绍。ElasticSearch是一个基于Lucene构建的开源搜索引擎，它提供了一个分布式、多用户...
JAVA API官方文档 中文版
04-21
Java API（应用程序接口）是Java编程语言的核心组成部分，它提供了大量的类库，使得开发者能够构建出功能丰富的应用程序。这份“JAVA API官方文档 中文版”是对于Java开发者的宝贵资源，帮助他们理解和使用Java平台...
数组转String并带分隔符
cqy646的专栏
06-02 7198
List list = new List();; String str = String.join(",", list.toArray(new String[list .size()]));
java使用分隔符连接数组中每个元素
Yan456jie的专栏
03-14 6372
public String listToString(List list, char separator) { return org.apache.commons.lang.StringUtils.join(list.toArray(),separator); }
java数组的api_java程序员常用的11个API，赶紧收藏
weixin_30162121的博客
02-21 887
一、Scanner 类一个可以解析基本类型和字符串的简单文本扫描器。package cn.wxuns;import java.util.Scanner;public class MyScanner {public static void main( String[] args){Scanner myScanner = new Scanner(System.in);System.out.printl...
Arrays.toString() 的用法
lorelei1001的专栏
04-28 4万+
在做项目的时候很想看一下byte数组里面具体放的数据，于是我直接打印了byte数组，但是结果是输出的居然是数组的地址，咕~~(╯﹏╰)b    于是查了一下，怎样才能将byte数组输出，找到了Arrays.toString(byte[] a) ,下面是在Arrays类里面这个方法的具体实现方法，我们不用管具体是怎么实现的，只要会使用就可以啦。  public static
List调用toString()方法后，去除两头的中括号
热门推荐
通往架构师之路
01-09 5万+
import org.apache.commons.lang.StringUtils; public class Test { public static void main(String[] args) { List list = new ArrayList(); list.add("1"); list.add("2"); list.add("3"); Sys
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值