New String数组 java java string类型数组

 String

String类是字符串，Java中所有字符串文字都被实现为此类的实例，也就是说，Java中所有带双引号的字符串都是String类的对象

特点：

1.字符串的值不可变，它们在创建后不可被改变；

2.虽然它们的值不可变，但是它们可以被共享；

3.字符串效果上相当于字符数组（char[]）,但是它们实际上却是字节数组（byte[]1）;

String构造方法

public String()  创建一个空白字符串，不含任何内容；

public String(char[] chs)  根据字符数组，来创建字符串对象

public String(byte[] bys)  根据字节数组，来创建字符串对象

String s="abc";  直接赋值的方式来创建对象，内容就是abc;

public class StringDemo {
    public static void main(String[] args) {
        String s1=new String();
        System.out.println("s1:"+s1);
//        s1:
        char[] chs= {'a','b','c'};
        String s2= new  String(chs);
        System.out.println("s2:"+s2);
//        s2:abc
        byte[] bys={97,98,99};
        String s3=new String(bys);
        System.out.println("s3:"+s3);
//        s3:abc
        String s4="abc";
        System.out.println("s4:"+s4);
//        s4:abc
    }
}

public String() public String(byte[] bytes)

public String(byte[] bytes,int offset,int length)

public String(char[] value)

public String(char[] value,int offset,int count)

public String(String original)

package com.one;

public class StringDemo {
    public static void main(String[] args) {
        //public String()
        String s = new String();
        System.out.println(s); //String类中重写toString()方法
        //查看字符串的长度
//        字符串s的长度为：0
        //public int length()返回此字符串的长度。
        System.out.println("字符串s的长度为：" + s.length()); //如果字符串中没有字符，返回0

        System.out.println("=====================================================");
        //public String(byte[] bytes)  //根据一个字节数组创建出一个字符串对象
        byte[] bytes = {97, 98, 99, 100, 101};
        String s2 = new String(bytes);
        System.out.println("s2: " + s2);
        System.out.println("字符串s2的长度为：" + s2.length());
//s2: abcde
//字符串s2的长度为：5
        System.out.println("=====================================================");
        //public String(byte[] bytes,int index,int length)
        //将字节数组中的一部分转化成字符串
        String s3 = new String(bytes, 1, 3);
        System.out.println("s3: " + s3);
        System.out.println("字符串s3的长度为：" + s3.length());
//s3: bcd
//字符串s3的长度为：3
        System.out.println("=====================================================");
        //public String(char[] value)
        //将字符数组转成一个字符串
        char[] c = {'a', 'b', 'c', 'd','我', '爱', '冯', '提', '莫'};
        String s4 = new String(c);
        System.out.println("s4: " + s4);
        System.out.println("字符串s4的长度为：" + s4.length());
//s4: abcd我爱冯提莫
//字符串s4的长度为：9
        System.out.println("=====================================================");
        //public String(char[] value,int index,int length)
        //将字符数组的一部分转成字符串
        String s5 = new String(c, 4, 4);
        System.out.println("s5: " + s5);
        System.out.println("字符串s5的长度为：" + s5.length());
//s4: 我爱冯提莫
//字符串s4的长度为：5
        System.out.println("=====================================================");
        //StringIndexOutOfBoundsException
//       String s6 = new String(c,4,10);
//        System.out.println("s6: "+s6);
//        System.out.println("字符串s5的长度为：" + s6.length());

        System.out.println("=====================================================");
        //public String(String original)
        String s7 = "你好";
        String s8 = new String(s7);
        System.out.println("s8: " + s8);
        System.out.println("字符串s8的长度为：" + s8.length());
//s8: 你好
//字符串s8的长度为：2

    }
}

看程序写结果：

public class StringDemo4 {
    public static void main(String[] args) {
        String s1 = new String("hello");
        String s2 = new String("hello");
        System.out.println(s1==s2);  // false
        System.out.println(s1.equals(s2)); // true

        String s3 = new String("hello");
        String s4 = "hello";
        System.out.println(s3==s4);// false
        System.out.println(s3.equals(s4)); // true

        String s5 = "hello";
        String s6 = "hello";
        System.out.println(s5==s6); // true
        System.out.println(s5.equals(s6)); // true
    }
}

1、字符串如果变量相加，是先在常量池中开辟空间，然后做拼接；

2、字符串如果是常量相加，是先相加，然后再去常量池中去寻找，如果找到了就返回，如果没有找到，就开辟新的空间，存储拼接后的值。

public class StringDemo5 {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "world";
        String s3 = "helloworld";
        String s4 = "hello"+"world";
        System.out.println(s3==s4); // true
        String s5 = s1+s2;
        System.out.println(s3==s5); // false
        System.out.println(s3==(s1+s2)); // false
        System.out.println(s3.equals(s1+s2)); // true
    }
}

String的判断功能：

boolean equals(Object obj)

boolean equalsIgnoreCase(String str)

boolean contains(String str)

boolean startsWith(String str)

boolean endsWith(String str)

boolean isEmpty()

package com.one;

public class StringDemo {

    public static void main(String[] args) {
        String s1 = "helloworld";
        String s2 = "Helloworld";
        String s3 = "HelloWorld";

        //boolean equals(Object obj)比较字符串中的内容是否相同,区分大小写比较的
        System.out.println(s1.equals(s2));
        System.out.println(s1.equals(s3));
        System.out.println("********************************");
        //boolean equalsIgnoreCase(String str)比较字符串中的内容是否相同,忽略大小写
        System.out.println(s1.equalsIgnoreCase(s2));
        System.out.println(s1.equalsIgnoreCase(s3));
        System.out.println("********************************");
        //boolean contains(String str)
        //判断大的字符串中是否包含小的字符串，如果包含，返回true，反之返回false
        //区分大小写
        System.out.println(s1.contains("Hello")); //false
        System.out.println(s1.contains("hel"));
        System.out.println(s1.contains("owo"));
        System.out.println("********************************");
        //boolean startsWith(String str)
        //测试此字符串是否以指定字符串开头
        //区分大小写
        System.out.println(s1.startsWith("hel"));
        System.out.println(s1.startsWith("Hel")); // false
        System.out.println(s1.startsWith("hell34")); // false
        System.out.println("********************************");
        //boolean endsWith(String str)
        //测试此字符串是否以指定字符串结尾
        //区分大小写
        System.out.println(s1.endsWith("rld"));
        System.out.println(s1.endsWith("rlD"));
        System.out.println("********************************");
        //boolean isEmpty()
        //判断字符串是否是空字符串
        System.out.println(s1.isEmpty());
        System.out.println("********************************");
        String s4 = "";
        String s5 = null;
        System.out.println(s4 == s5);
        System.out.println(s5 == s4);
        System.out.println(s4.equals(s5)); //false
//        System.out.println(s5.equals(s4)); // NullPointerException

        /**
         *      注意：今后在做字符串比较内容的时候，很容易出现NullPointerException空指针异常
         *      前面调用方法的变量有可能是null值
         *      所以今后，为了避免出现这样的问题，如果是变量1.equals(变量2)的时候，在做equals之前判断一下变量1是不是null
         *      如果是一个变量1与字符串常量1做equals比较的时候，把字符串常量1放在前面调用方法，因为我们说过单独一个字符串也是一个String对象
         *
         */

        //需求：比较s6的值是否和s7的值一样
        String s6 = null;
        String s7 = "hello";
        if (s6 != null) {
            if (s6.equals(s7)) {
                System.out.println("是一样的");
            }
        } else {
            System.out.println("s6是null值");
        }

        //需求2：判断s6的值是否是hello
//        if(s6.equals("hello")){
//            System.out.println("是一样的");
//        }
        if ("hello".equals(s6)) {
            System.out.println("是一样的");
        } else {
            System.out.println("s6的值不是hello");
        }
    }
}

String的获取功能：

int length()

char charAt(int index)

int indexOf(int ch)

int indexOf(String str)

int indexOf(int ch,int fromIndex)

int indexOf(String str,int fromIndex)

String substring(int start)

String substring(int start,int end)

package com.one;

public class StringDemo {

    public static void main(String[] args) {
        String s = "helloworld";

        //int length() 获取字符串的长度
        System.out.println("字符串s的长度为："+s.length());
        System.out.println("==================================");
        //char charAt(int index) 返回指定索引处的字符
        //0<=index<=length()-1
        System.out.println(s.charAt(4));
        System.out.println(s.charAt(0));
        //StringIndexOutOfBoundsException
//        System.out.println(s.charAt(100));
        System.out.println(s.charAt(9));

        System.out.println("==================================");
        //public int indexOf(int ch)返回指定字符第一次出现的字符串内的索引。
        //需求：获取o在字符串中第一次出现的位置
        System.out.println(s.indexOf('o'));
        //如果此字符串中没有此类字符，则返回-1 。
        System.out.println(s.indexOf(97));

        System.out.println("==================================");
        //public int indexOf(String str)返回指定子字符串第一次出现的字符串内的索引。
        //返回的是小串的第一个字符在大串中出现的索引位置
        //owo
        System.out.println(s.indexOf("owo"));
        //如果大串中不存在小串，返回-1
        System.out.println(s.indexOf("owe"));
        System.out.println(s.indexOf("qwer"));

        System.out.println("==================================");
        // public int indexOf(int ch,int fromIndex)
        // 返回指定字符第一次出现的字符串内的索引，以指定的索引开始搜索。
        //如果找到了，返回的是字符在整个字符串中的索引
        System.out.println(s.indexOf("l",4)); // 8
        System.out.println(s.indexOf("l",1000)); // -1
        System.out.println(s.indexOf("p",4)); // -1
        System.out.println(s.indexOf("p",1000)); // -1

        System.out.println("==================================");
        // int indexOf(String str,int fromIndex)
        System.out.println("==================================");
        //helloworld
        //String substring(int start) 从指定位置处截取字符串，包括开始截取的位置，截取到末尾
        //如果给的索引值不存在，报错
        System.out.println(s.substring(3)); // loworld
//        System.out.println(s.substring(100)); // StringIndexOutOfBoundsException

        System.out.println("==================================");
        //String substring(int start,int end)
        //截取字符串的一部分出来
        //截取的串从start位置开始截取，截取到end-1的位置结束
        //左闭右开 [,)  含头不含尾。
        System.out.println(s.substring(5,8)); // wor
//        System.out.println(s.substring(1,20)); //StringIndexOutOfBoundsException





    }
}

String的转换功能：

byte[] getBytes()

char[] toCharArray()

static String valueOf(char[] chs)

static String valueOf(int i)

String toLowerCase()

String toUpperCase()

String concat(String str)

package com.one;

public class StringDemo {

    public static void main(String[] args) {
        String s = "HelloWorLD";

        //public byte[] getBytes()使用平台的默认字符集将此String编码为字节序列，将结果存储到新的字节数组中。
        //将字符串转成字节数组
        byte[] bytes = s.getBytes();
//        System.out.println(bytes);
        for(int i=0;i<bytes.length;i++){
            System.out.print(bytes[i]);
        }
        //72 101 108 108 111 87 111 114 76 68

        System.out.println();
        System.out.println("=================================");
        //char[] toCharArray()
        //将字符串转成字符数组
        char[] chars = s.toCharArray();
        for(int i=0;i<chars.length;i++){
            System.out.println(chars[i]);
        }

        //增强for循环，后面上到集合的时候，我们会讲解
//        for(char c : chars){
//            System.out.println(c);
//        }
        System.out.println("=================================");
        //static String valueOf(char[] chs)
        //将字符数组转成字符串
        String s1 = String.valueOf(chars);
        System.out.println(s1);
//HelloWorLD
        System.out.println("=================================");
        //static String valueOf(int i) 数据库
        //将int类型的数据转成字符串
        String s2 = String.valueOf(100); // 100 --> "100"
        System.out.println(s2); //100

        System.out.println("=================================");
        //String toLowerCase()
        //将字符串中的内容全部转小写
        String s3 = s.toLowerCase();
        System.out.println(s3); //helloworld

        System.out.println("=================================");
        //String toUpperCase()
        String s4 = s.toUpperCase();
        System.out.println(s4); //HELLOWORLD

        System.out.println("=================================");
        //String concat(String str)
        //将小括号中str的字符串拼接到大字符串的后面
        String s5 = s.concat("hadoop");
        System.out.println(s5);

        System.out.println("=================================");
        //public String[] split(String s)
        String s6 = "hello world hello java world";
        //需求：求出字符串中的每一个单词
        String[] strings = s6.split(" ");
        for(int i=0;i<strings.length;i++){
            System.out.println(strings[i]);
        }


    }
}

替换功能 String replace(char old,char new)

String replace(String old,String new) 去除字符串两空格    

String trim() 按字典顺序比较两个字符串

  int compareTo(String str)

int compareToIgnoreCase(String str)

public static void main(String[] args) {
        String s = "hellowrodldajavahadoopowollohelloowo";

        //String replace(char old,char new)
        //将新的字符串替换字符串中指定的所有字符，并返回一个替换后的字符串
        String s1 = s.replace('l', 'q');
        System.out.println(s);
        System.out.println(s1);

        System.out.println("====================================");
        //String replace(String old,String new)
        //将字符串中就的小串用新的小串替换，返回一个替换后的字符串
        String s2 = s.replace("owo", "===");
        System.out.println(s);
        System.out.println(s2);
        System.out.println();
        String s3 = s.replace("owo", "@@@@");
        System.out.println(s);
        System.out.println(s3);
        System.out.println();
        //如果被替换的字符串不存在会是什么情况呢？返回的是原本的字符串
        String s4 = s.replace("qwer", "LOL");
        System.out.println(s);
        System.out.println(s4);

        System.out.println("====================================");
        //String trim() 去除字符串两边的若干个空格
        String s5 = "   hello world  ";
        System.out.println(s5);
        System.out.println(s5.trim());

        System.out.println("====================================");
        //int compareTo(String str)  //比较字符串是否相同，如果相同返回0
        String s6 = "hello"; // h的ASCII码值是 104
        String s7 = "hello";
        String s8 = "abc";   // a的ASCII码值是 97
        String s9 = "qwe";   // q的ASCII码值是 113
        System.out.println(s6.compareTo(s7)); // 0
        System.out.println(s6.compareTo(s8)); // 7
        System.out.println(s6.compareTo(s9)); // -9

        String s10 = "hel";
        System.out.println(s6.compareTo(s10)); // 2



    }
}

把一串字母的首字母转换为大写，其他为小写；

public static void main(String[] args) {
        String s = "hADoopJava";
        System.out.println("转换之前：" + s);

        //将字符串中的所有字符全部转小写
        String s1 = s.toLowerCase();
        //获取第一个字符
//        char s2 = s1.charAt(0);
        String s2 = s1.substring(0, 1);
        //将第一个字符转大写
        String s3 = s2.toUpperCase();
        //获取除第一个字符以外的其他字符
        String s4 = s1.substring(1);
        //将转大写的字符与其余的字符做拼接
        String result = s3.concat(s4);
        System.out.println("转换之后：" + result);

        System.out.println("==================用链式编程转换==================");
        String result2 = s.substring(0, 1)
                .toUpperCase()
                .concat(s.substring(1).toLowerCase());
        System.out.println("转换之后：" + result2);
    }
}

把数组按指定的格式拼接成一个字符串：
int[] arr={1,2,3}    输出[1,2,3]

public static void main(String[] args) {
        int[] arr = {1,2,3};
        String s = "";
        for(int i=0;i<arr.length;i++){
            String s1 = String.valueOf(arr[i]);
            if(i==0){
                System.out.print(s.concat("[").concat(s1).concat(","));
            }else if(i==arr.length-1){
                System.out.print(s.concat(s1).concat("]"));
            }else {
                System.out.print(s.concat(s1).concat(","));
            }
        }
        System.out.println(s);


    }
}

字符反转：键盘输入“abc”,输出“cba”;

import java.util.Scanner;

public class StringTest4 {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String s = sc.next();
        //创建一个空的字符串
        String s1 = "";
        //将字符串转成字符数组
        char[] chars = s.toCharArray();
        //倒着遍历，得到每一个字符
        for (int i = chars.length - 1; i >= 0; i--) {
            //将每个字符转成字符串
            String s2 = String.valueOf(chars[i]);
//            System.out.println(s2);
            //将每次获取到的字符进行拼接
            s1 = s1.concat(s2);
        }

        System.out.println("倒序后的字符串为：" + s1);


    }
}

统计大串中小串中出现的次数；

举例：在字符串” woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagundasdqwdeqwdwdasvgwrefasjavajavajijijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagundaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagundaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagundaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagundaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagundaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagundaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagundaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagunda”
        中java出现了5次

 */
public class StringTest5 {
    public static void main(String[] args) {
        //创建一个字符串
        String bigString = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagundasdqwdeqwdwdasvgwrefasjavajavajijijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagundaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagundaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagundaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagundaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagundaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagundaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagundaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagunda";

        //定义要查找的小串：java
        String minString = "java";

        //定义一个变量统计小串出现的次数
        int count = 0;

        //在大串中找到小串第一次出现的位置
        int index = bigString.indexOf(minString);

        //也有可能第一次找的时候就没有找到
        if (index == -1) {
            System.out.println("该大串中没有小串" + minString);
        } else {
            while (index != -1) {
                count++;
                //截取字符串
                int startIndex = index + minString.length();
                bigString = bigString.substring(startIndex);
                //继续去找小串出现的位置索引
                index = bigString.indexOf(minString);
                System.out.println("找到了小串，截取后的大串为："+bigString);
            }
        }
        System.out.println("======================================================");

        System.out.println(minString + "在大串" + bigString + "中出现的次数为：" + count);


    }
}