java学习笔记1

134明目

已于 2024-04-14 19:10:51 修改

阅读量1.6k

点赞数 32

文章标签：学习笔记

于 2024-03-26 14:12:52 首次发布

本文链接：https://blog.csdn.net/2301_77060648/article/details/136828668

版权

在学习Java与生活课程中或者是在所有的编程类学习中，大部分内容是需要自己进行反复大量的练习，所以做笔记是非常有助于加深记忆，并且也是一种对自己学习的记录。本笔记只写本人认为需要记录的地方，仅供参考。

一.String 的那些方法

String方法来自java 8 doc

charAt(int index);

返回指定索引处的字符:索引从0开始

//char
        String str_1 = "hello";
        //返回指定的字符串中的字符
        System.out.println("第一个字符 ：" + str_1.charAt(0));
    //运行结果：
//第一个字符 ：h

codePointAt(int index);

返回指定索引处字符的十进制ASCII码

//Int
        String str_1 = "hello";
        //返回指定的字符串中字符的值
        System.out.println("第一个字符 ：" + str_1.codePointAt(0));
/*运行结果 ：
第一个字符 ：104
*/

codePointBefore(int index);

返回指定索引前一位字符的十进制ASCII码

//int
        String str_1 = "hello";
        //返回指定的字符串中指定位置前一位字符的值
        System.out.println("第2个字符 ：" + str_1.codePointBefore(2));
//运行结果：
//第2个字符 ：101

codePointCount(int beginIndex , int endIndex);

返回指定区间内字符的字符个数，包头不包尾

//int 
String str_1 = "hello";
        //返回该String指定范围内的字符
        System.out.println(str_1.codePointCount(0,2));
//运行结果：2

str_1.compareTo(str_2);

举例：X.compareTo(Y);

考虑字符大小写

按顺序比较两个字符串，如果字符串前面相等后面不相等，则找到第一次不同处求Xn-Yn的十进制ascall码值，结果为正，反之为负。如果前面相等后面X字符串结束了但Y字符串还没有结束，此时输出结果为Y字符串剩余字符个数，结果为负，反之Y与X比较结果为正。

//int
String str_1 = "a";
    String str_2 = "c";
        System.out.println(str_1.compareTo(str_2));
运行结果：-2

str_1.compareToIgnoreCase(str_2);

与上一个基本一样，除比较的时候不区分大小写

//int
String str_1 = "ab";
    String str_2 = "Ac";
        System.out.println(str_1.compareToIgnoreCase(str_2));
//运行结果：-1

str_1.concat(str_2);

该方法将指定的字符串连接到该字符串的末尾

//Sting
String str_1 = "hello ";
    String str_2 = "world!";
        System.out.println(str_1.concat(str_2));
//运行结果：hello world!

str_1.contains("字符");

该方法利用if 语句判断字符串中是否包含指定的char的字符/字符串，true&false

//boolean
String str_1 = "hello";
        if(str_1.contains("ell")){
            System.out.println("true");
        }else{
            System.out.println("false");
        }
//运行结果：true

str_2.contentEquals("cs/sb :字符");

该方法实现判断字符串是否与指定的字符/字符串相同

//boolean
String str_2 = "world!";
        if(str_2.contentEquals("world")){
            System.out.println("true");
        }else{
            System.out.println("false");
        }
//运行结果：false

str_2 = str_2.copyValueOf(char [ ] data);
str_2 = str_2.copyValueOf(char [ ] data,offest,count);

该方法实现返回指定数组中表示该字符序列的字符串。

//static String 
char [] x = {'h','e','l','l','o'};
        String str_2 = "world!";
        str_2 = str_2.copyValueOf(x);
        System.out.println("str_2 = " + str_2);//运行结果：hello
        
        System.out.println("     data   offset    count");
        str_2 = str_2.copyValueOf(x,1,3);
        System.out.println("str_2 = " + str_2);//运行结果：ell
        System.out.println("data — 字符数组");
        System.out.println( "offset — 子数组的初始偏移量。" );
        System.out.println("count — 子数组的长度。");

endsWith(String suffix);

该方法实现测试此字符串是否以指定的后缀结尾

//boolean
String str_2 = "world!";
        if(str_2.endsWith("l")){
            System.out.println("true");
        }else
            System.out.println("false");
//运行结果：false

if(str_2.equals("str_1"));

该方法实现将字符串与指定的对象进行比较，判断是否一致

//boolean
String str_1 = "world.";
       String str_2 = "world!";
       //if(str_2.equals(也可以直接填入字符串)
        if(str_2.equals(str_1)){
            System.out.println("true");
        }else
            System.out.println("false");
//运行结果；false

str_2.equalsIgnoreCase(str_1);

该方法实现两个字符串相比较是否一致(不区分大小写)

//boolean
String str_1 = "WORLD!";
       String str_2 = "world!";
        if(str_2.equalsIgnoreCase(str_1)){
            System.out.println("true");
        }else
            System.out.println("false");
//true

String.format("hi,%s","haha");

字符串格式参数不但可以灵活将其他数据类型转换成字符串，而且可以与各种标志组合在一起，生成各种格式的字符串

static Sting
String str_1 = null;
        str_1 = String.format("hi,%s","haha");
        System.out.println("str_1 = " + str_1);
        System.out.printf( "字母a的大写是：%c %n" , 'A' );
        System.out.printf( "3>7的结果是：%b %n" , 3 > 7 );
        System.out.printf( "100的一半是：%d %n" , 100 / 2 );
        System.out.printf( "100的16进制数是：%x %n" , 100 );
        System.out.printf( "100的8进制数是：%o %n" , 100 );
        System.out.printf( "50元的书打8.5折扣是：%f 元%n" , 50 * 0.85 );
        System.out.printf( "上面价格的16进制数是：%a %n" , 50 * 0.85 );
        System.out.printf( "上面价格的指数表示：%e %n" , 50 * 0.85 );
        System.out.printf( "上面价格的指数和浮点数结果的长度较短的是：%g %n" , 50 * 0.85 );
        System.out.printf( "上面的折扣是%d%% %n" , 85 );
        System.out.printf( "字母A的散列码是：%h %n" , 'A' );

String str = String.format("%d",400/2);

该方法实现格式字符串->计算参数->转换类型输出

//static string
String str = String.format("%d",400/2);
        System.out.println("str = " + str);
//运行结果：str = 200

	一个汉字	一个字符
UTF8	3	1
GBK	2	1
ISO88591	1	1
Unicode	2n+2	2n+2

byte[] b_gbk = "大大".getBytes("GBK");
        byte[] b_utf8 = "大大".getBytes("UTF-8");
        byte[] b_iso88591 = "大大".getBytes("ISO8859-1");
        byte[] b_unicode = "哒哒哒哒".getBytes("unicode");
        System.out.println("length:"+b_gbk.length);
        System.out.println("length:"+b_utf8.length);
        System.out.println("length:"+b_iso88591.length);
        System.out.println("length:"+b_unicode.length);
        /**
         * length:4
         * length:6
         * length:2
         * length:10
         */

geteBytes();
geteBytes(Charset Charset);
geteBytes(CharsetName ) ;
hashCode();

该方法实现输出指定字符串的哈希码

//int
String s = "ok";
        System.out.println(s.hashCode());
//输出结果:3548

s.indexOf(int ch)
s.indexOf(String str)

该方法实现寻找在字符串中第一次出现的该指定字符/字符串，输出该字符/字符串位置（从零开始），没有查找到返回-1

//int
 String s = "oka";
        System.out.println(s.indexOf('k'));
//运行结果：1

s.indexOf(int ch,int formIndex)
s.indexOf(String str,int formIndex)

该方法实现寻找在字符串中第一次出现的该指定字符，从指定位置开始寻找，查询不到-1

//int
String s = "oka";//             指定字符 ，指定位置
        System.out.println(s.indexOf('k',0));
//运行结果：1

intern（）；

不管是String对象，还是字面量，只要他们的值相等，调用intern()都会返回同一个字符串常量池的引用

//string
 String s = "oka";
        System.out.println(s.intern() == s);
//运行结果：true

isEmpty()

用于判断List内容是否为空

join(CharSequence delimiter, CharSequence... elements)；

List<String> strings = List.of(" CharSequence... elements", ......." CharSequence... elements");

String message = String.join("CharSequence delimiter", strings);

该方法实现将原多个字符串组成一个新的字符串，并用分隔符隔开

//static Sting
String s = String.join("-","hello","world","!");
        System.out.println("s = " + s);
//运行结果：s = hello-world-!
//另一种方法 1.8起
 List<String> strings = List.of("hello", "world", "!");
    String message = String.join("-", strings);
  System.out.println("s = " + s);
//运行结果：s = hello-world-!

lastIndexOf(int ch);
lastIndexOf(String str);

该方法实现查询指定字符/子字符串在该字符串中最后出现的位置，并输出其位置（从零开始）

//int
 String str = "level";
        System.out.println(str.lastIndexOf('e'));
//运行结果：3
 String str = "level";
        String str_1 = "vel";
        System.out.println(str.lastIndexOf(str_1));
//运行结果：2

lastIndexOf(int ch , int formIndex) ；
lastIndexOf(String str , int formIndex) ；

返回指定字符/子字符串的最后一次出现的字符串中的索引，从指定的索引(字符和位置都可以)开始向后搜索

//int
 String str = "level";
        System.out.println(str.lastIndexOf('e', '0'));
//运行结果：3
String str = "level";
        String str_1 = "vel";
        System.out.println(str.lastIndexOf(str_1,'l'));
//运行结果：2

length();

该方法实现求字符串长度

//int
String str_1 = "level";
        System.out.println(str_1.length());
//运行结果：5

matches（regex）；

regex是一个表示正则表达式的字符串。

调用matches()方法后，如果字符串与给定的正则表达式匹配，则返回true，否则返回false。

下面是一个示例代码，用来判断一个字符串是否为合法的邮箱地址：

regionMatches(int toffset, String other, int ooffset, int len)

regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)

方法测试两个指定字符串区域是否相等。此String对象的子字符串与参数other的子字符串进行比较。

gnoreCase - 如果为true，则在比较字符时忽略大小写。
toffset - 此字符串toffset区域的起始偏移量。
other - 字符串参数。
ooffset - 字符串参数ooffset区域的起始偏移量。
len - 要比较的字符数。

//boolean
String str_1 = "java hello world!";
        String str_2 = "C hello world!";
        String str_3 = "C Hello World!";
        boolean match1 = str_1.regionMatches(5, str_2, 2, 12);
//运行结果：true
        System.out.println("match1 = " + match1);
        boolean Match1 = str_1.regionMatches(true,5,str_3,2,12);
//运行结果：true

replace(char oldchar , char new char);

replace(CharSequence target, CharSequence replacement)

方法替换所有字符串中出现的/字符子字符串；

//String
 String str_1 = "java hello hworld!";
      str_1 =  str_1.replace('h', 'c');
        System.out.println("str_1 = " + str_1);
//运行结果：str_1 = java cello hworld!
String str_1 = "java hello hworld!";
      str_1 =  str_1.replace("h", "ss");
        System.out.println("str_1 = " + str_1);
//str_1 = java ssello ssworld!

public String replaceAll(String regex, String replacement)

使用给定的参数 replacement 替换字符串所有匹配给定的正则表达式的子字符串
如果是正则:成功返回子串，失败返回原字符串，如果是字符串，成功返回替换后的，失败返回原字符串

//String
 String str = "www.google.com";
        System.out.println("true return : ");
        System.out.println(str.replaceAll("(.*)google(.*)", "qq"));
        System.out.println("false return : ");
        System.out.println(str.replaceAll("(.*)fixfox(.*)" , "wechat"));
/*true return : 
qq
false return : 
www.google.com
*/

public String replaceFirst(String regex, String replacement)

跟上面replaceAll(String regex, String replacement)一样，只不过该方法只匹配第一个

........

split(String regex)

字符串分割，将字符串按照指定字符进行分割，返回的是一个字符串数组。

值得注意的是Java中使用String.split对有些特殊字符进行分割时需要进行转义才能进行分割。

例如：“| " ,”*", ". "等，否则无法分割会报错。

//String []
//转义字符示例split()
        String str = "a.b.c.d";
        String s [] = str.split("\\.");
        System.out.println(s[0]); //a
        System.out.println(s[1]); //b
        System.out.println(s[2]); //c
        System.out.println(s[3]); //d
//非需要转义字符示例split()
        String str_1 = "a b c d";
        String s1 [] = str_1.split(" ");
        System.out.println(s1[0]); //a
        System.out.println(s1[1]); //b
        System.out.println(s1[2]); //c
        System.out.println(s1[3]); //d

split(string retex , int limit)

按照指定的分隔符regex，分隔字符串String；分隔结果为String[ ]格式

limit的用法如下：

limit 参数通过控制分割次数从而影响分割结果
如果传入 n(n>0) 那么字符串最多被分割 n-1 次,分割得到数组长度最大是 n
如果 n = -1 将会以最大分割次数分割
如果 n = 0 将会以最大分割次数分割,但是分割结果会舍弃末位的空串

//String
//转义字符示例split()
        String str = "a.b.c.d";
        String s [] = str.split("\\.",3);
        System.out.println(s[0]);//a
        System.out.println(s[1]);//b
        System.out.println(s[2]);//c d
        System.out.println(s[3]);
        //非需要转义字符示例split()
        String str_1 = "a b c d ";
        String s1 [] = str_1.split(" ",-1);
        System.out.println(s1[0]);//a
        System.out.println(s1[1]);//b
        System.out.println(s1[2]);//c
        System.out.println(s1[3]);//d

startsWith(String prefix);

判断是否以prefix(指定字符)开头

//boolean
String str = "hello";
            System.out.println(str.startsWith("h"));
//运行结果：true

startsWith(String prefix, int toffset)
测试在指定索引处开始的此字符串的子字符串是否以指定的前缀开头。

//boolean
 String str = "hello";
        System.out.println(str.startsWith("hel",0)); //true
        System.out.println(str.startsWith("el",0)); //false
            System.out.println(str.startsWith("el",1)); //true

subSequence(int beginIndex, int endIndex)

此方法返回一个新的字符序列，该序列是该序列的子序列。

beginIndex - 包含开始索引。
endIndex - 不包含结束索引。

//String
String str = "Java to hello world";
        System.out.println(str.subSequence(0 , 10));//Java to he
        System.out.println(str.subSequence(10 , 15));//llo w

substring(int beginIndex)

substring(int beginIndex, int endIndex)//包头不包尾
返回一个字符串，该字符串是此字符串的子字符串。

//String
 String str = "Java to hello world";
        System.out.println(str.substring(8));
//运行结果:hello world
  String str = "Java to hello world";
        System.out.println(str.substring(8,14));
//运行结果：hello

toCharArray()

用法:是将字符串对象中的字符转换为一个字符数组

//char []
String str = "Java.to.hello.world";
        char[] s = str.toCharArray();
        System.out.println(s);
//运行结果：Java.to.hello.world

toLowerCase()

用途是字符串中的字母被转换为小写字母。

toUpperCase()

用途是字符串中的字母被转换为大写字母。

//String
 String str = "Java.To.Hello.World";
        System.out.println(str.toLowerCase());
//运行结果：java.to.hello.world
//
  String str = "Java.To.Hello.World";
        System.out.println(str.toUpperCase());
//运行结果：JAVA.TO.HELLO.WORLD

trim()

返回一个字符串，其值为此字符串，并删除任何前导和尾随空格

//String
 String str = " Java.To.Hello.World ";
        System.out.println(str.trim());
//运行结果：Java.To.Hello.World

static String valueOf(boolean b);
static String valueOf(char c);
static String valueOf(char[] data);
static String valueOf(char[] data, int offset, int count);
static String valueOf(double d);
static String valueOf(float f);
static String valueOf(int i);
static String valueOf(long l);
static String valueOf(Object obj);

返回指定参数的字符串表示形式。

返回值是删除头尾空白符的字符串。

//static String
boolean b = true;
        System.out.println(String.valueOf(b));
     char ch = 'z';
        System.out.println(String.valueOf(ch));
     char [] s = {'j','a','v','a'};
        System.out.println(String.valueOf(s));
     double d = 100.00;
        System.out.println( String.valueOf(d));
     float f = 90;
        System.out.println(String.valueOf(f));
     int i = 4;
        System.out.println(String.valueOf(i));
     long l = 123456789;
        System.out.println(String.valueOf(l));
/*运行结果：
true
z
java
100.0
90.0
4
123456789*/