Java Scanner String

最新推荐文章于 2024-03-15 21:33:05 发布

LCYeezus

最新推荐文章于 2024-03-15 21:33:05 发布

阅读量223

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_47884045/article/details/110958930

版权

12.01_Scanner类的hasNextXxx()

  A：基本格式
  			hasNextXxx()	判断下一个是否是某种类型的元素，其中Xxx可以是
  							Int，Double等。如果需要判断是否含下一个字符串
  							则可以省略Xxx
  							
  			nextXxx()		获取下一个输入项，Xxx的含义和上个方法中的Xxx
  							相同

12.02_Scanner获取数据出现的小问题及解决

  A：常用的方法：
  		public int nextLine()：获取一个int类型的值
  		public String nextLine()：获取一个String类型的值
  		public String next()：获取一个String类型的值

12.03_String类的概述

  A：什么是字符串
  			字符串是由多个字符组成的一串数据（字符序列）
  			字符串可以看成是字符数组
			字符串是常量，一旦被创建，就不能被改变
			字符串字面值也可以看成是一个字符串对象
  B：常见构造方法
  			public String()：空构造
  			public String(byte[] bytes)：把字节数组转成字符串
  			public String(byte[] bytes,int index,int length)：把字节数
  							 组的一部分转成字符串（index：表示从第几个索
  							 引开始，length表示的是长度）
  			public String(char[] value)：把字符数组转成字符串
  			public String(char[] value,int index,int count)：把字符数
  							 组的一部分转成字符串
  			public String(String original)：把字符串常量转成字符串

12.04_String类的判断功能

  A：String类的判断功能
  		   public boolean equals(Object obj)：比较字符串的内容是否相同，
  		   									  区分大小写
  		   public boolean equalsIgnoreCase(String str)：比较字符串的内
  		   												容是否相同，忽略大小写
  		   public boolean contains(String str)：判断字符串中是否包含传
  		   										递进来的字符串
  		   public boolean startsWith(String str)：判断字符串是否以传递
  		   										  进来的字符串开头
  		   public boolean endsWith(String str)：判断字符串是否以传递进
  		   										来的字符串结尾
  		   public boolean isEmpty()：判断字符串的内容是否为空串""

12.05_String类的获取功能

  A：String类的获取功能
  		   public int length()：获取字符串的长度
  		   public char charAt(int index)：获取指定索引位置的字符
  		   public int indexOf(int ch)：返回指定字符在此字符串中第一次出
  		   							   现处的索引
  		   public int indexOf(String str)：返回指定字符串在此字符串中第
  		   								   一次出现处的索引
  		   pubic int indexOf(int ch,int fromIndex)：返回指定字符在此字
  		   											符串中从指定位置后
  		   											第一次出现处的索引
  		   pubic int indexOf(String str,int fromIndex)：返回指定字符串
  		   												在此字符串中从
  		   												指定位置后第一
  		   												次出现处的索引
  		   public String substring(int start)：从指定位置开始截取字符串，
  		   									   默认到末尾
  		   public String substring(int start,int end)：从指定位置开始
  		   											   到指定位置结束
  		   											   截取字符串

12.06_String类的转换功能

  A：String的转换功能：
  		   public byte[] getBytes()：把字符串转换为字节数组
  		   public char[] toCharArray()：把字符串转换为字符数组
  		   public static String valueOf(char[] cha)：把字符数组转成字符串
  		   public static String valueOf(int i )：把int类型的数据转成字符串
  		   	注意：String类的valuOf方法可以把任意类型的数据转成字符串
  		   public String toLowerCase()：把字符串转成小写
  		   public String toUpperCase()：把字符串转成大写
  		   public String concat(String str)：把字符串拼接

12.07_String类的其他功能

  A：String的替换功能
  		   public String replace(char old,char new)：将指定字符进行互换
  		   public String replace(String old,String new)：将指定字符串进行互换

12.08_StringBuffer类的概述

  A：StringBuffer类的概述
  		我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对
  		象，既耗时，又浪费空间，而StringBuffer就可以解决这个问题
  		线程安全的可变字符序列
  B：StringBuffer的构造方法：
  		public StringBuffer()：无参构造方法
  		public StringBuffer(int capacity)：指定容量的字符串缓冲区对象
  		public StringBuffer(String str)：指定字符串内容的字符串缓冲区对象
  C：StringBuffer的方法：
  		public int capacity()：返回当前容量。		理论值
  		public int length()：返回长度（字符数）。	实际值
  D：StringBuffer的添加功能：
  		public StringBuffer append(String str)：可以把任意类型数据添加
  												到字符串缓冲区里面，并
  												返回字符串缓冲区本身
  		public StringBuffer insert(int offset,String str)：在指定位置把任意类型
  														   的数据插入到字符串缓冲
  														   区里面，并返回字符串缓
  														   冲区本身
  E：StringBuffer的删除功能：
  		public StringBuffer deleteCharAt(int index)：删除指定位置的字符，
  													 并返回本身
  		public StringBuffer delete(int start,int end)：删除从指定位置开始指定
  													   位置结束的内容，
  													   并返回本身
  F：StringBuffer的替换功能：
  		public StringBuffer replace(int start,int end,String str)：从start开始
  																   到end用str替换
  G：StringBuffer的反转功能：
  		public StringBuffer reverse()：字符串反转
  H：StringBuffer的截取功能
  		public String substring(int start)：从指定位置截取到末尾
  		public String substring(int start,int end)：截取从指定位置开始
  													到结束位置，包括开始位
  													置，不包括结束位置

12.09_StringBuffer和String的相互转换

  A：String -- StringBuffer
  		   a：通过构造方法
  		   b：通过append()方法
  B：StringBuffer -- String
  		   a：使用substring方法
  		   b：通过构造方法
  		   c：通过toString()方法
  C：形式参数问题
  		   String作为参数传递，String虽然是引用类型，但它是一个常量，所以在
  		   做传递的时候，完全可以将其看成基本数据类型进行传递，String类型
  		   输入值传递
  		   StringBuffer作为参数传递
  		   
  补充：StringJoiner
  			StringJoiner(CharSequence delimiter)
  			构建了一个字符容器，指定分隔符
  			
  			StringJoiner(CharSequence delimiter,CharSequence prefix,CharSequence suffix)
  			构建了一个字符容器，指定分隔符、前缀、后缀

		    StringJoiner add(CharSequence newElement)
		    增加一份给CharSequ值的 StringJoiner价值的下一个元素

		    int length()
		    返回该StringJoiner的String表示长度

		  	String toString()	把容器中的数据以字符串返回

举例

1.字符串比较、字符串开头结尾

public class MyTest {
    public static void main(String[] args) {
        //判断两个字符串字面上的内容是否形同，区分大小写
        boolean b1 = "abc".equals("ABC");
        System.out.println(b1);
        //判断两个字符串字面上的内容是否形同，不区分大小写
        boolean b = "abc".equalsIgnoreCase("ABC");
        System.out.println(b);
        //判断一个字符串里面是否包含这个子串contains()
        String s = "我想要带你去浪漫的土耳其，还要一起去东京和巴黎";
        System.out.println(s.contains("土耳其22222"));

        //判断一个字符串是不是空串
        boolean b2 = "".isEmpty();
        System.out.println(b2);
        if("".length() == 0){
            System.out.println("是空串");
        }

        //判断一个字符传是不是以这个字符串开头或结尾
        System.out.println("王语嫣".startsWith("王"));
        System.out.println("段誉".endsWith("段"));
    }
}

2.indexOf()

public class MyTest {
    public static void main(String[] args) {
        //在一段字符串中查询一个字符或字符串第一次出现的索引,如果没有查找到会返回-1，我们经常会用-1来做判断
        String s="简只简单单，只为教育。爱生活，爱Java!只";
        int index = s.indexOf('只');
        System.out.println(index);
        int index1 = s.indexOf("爱生活2");
        System.out.println(index1);
        //我要查找只第二次出现索引
        //从哪个索引开始，去查找该字符
        int index2 = s.indexOf("只",s.indexOf("只")+1);
        System.out.println(index2);

        //从后往前检索
        int index3 = s.lastIndexOf("只");
        System.out.println(index3);
    }
}

3.charAt()

public class MyTest {
    public static void main(String[] args) {
        //根据索引获取单个字符
        String s="西部开源教育科技有限公司";
        char ch = s.charAt(0);
        System.out.println(ch);

        //StringIndexOutOfBoundsException 字符串角标越界异常
        char ch2 = s.charAt(s.length()-1);
        System.out.println(ch2);
    }
}

public class MyTest {
    public static void main(String[] args) {
        String s="简简单单，只为教育。爱生活，爱Java!";
        //遍历
        for(int i = 0;i < s.length();i++){
            char ch = s.charAt(i);
            System.out.print(ch);
        }
        System.out.println();
        System.out.println("=========================");
        //反向遍历
        for(int i = s.length()-1;i >= 0;i--){
            char ch = s.charAt(i);
            System.out.print(ch);
        }
    }
}

public class MyTest {
    public static void main(String[] args) {
        //案例演示:
        //需求：统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)
        String s="asdfasdfWDSSFdsdfsdDIFDIF1111558asdfasdf33224447899554";

        //怎么判断这个字符是大写字母，小写字母 数字字符
        int xiao = 0;
        int da = 0;
        int num = 0;
        for(int i = 0;i < s.length();i++){
            char ch = s.charAt(i);
            if(ch >= 'a' && ch <= 'z'){
                xiao++;
            }else if(ch >= 'A' && ch <= 'Z'){
                da++;
            }else if(ch >= '0' && ch <= '9'){
                num++;
            }
        }
        System.out.println("大写字母"+da+"个");
        System.out.println("小写写字母" + xiao + "个");
        System.out.println("数字字符" + num + "个");
    }
}

4.substring()

public class MyTest {
    public static void main(String[] args) {
        String s="简简单单，只为教育。爱生活，爱Java!";
        //根据起始索引，截取到末尾
        String s1 = s.substring(2);
        System.out.println(s1);

        //根据起始索引和终止索引，截取一部分字符串，含头不含尾
        String s2 = s.substring(5,9);
        System.out.println(s2);

        String s3 = s.substring(s.indexOf('只'),9);
        System.out.println(s3);
    }
}

5.字符串字节数组

public class MyTest {
    public static void main(String[] args) {
        //把字符串转换成字节数组
        String s="西部开源";
        byte[] bytes = s.getBytes();
        for(int i = 0;i < bytes.length;i++){
            System.out.println(bytes[i]);
        }

        //把字节数组，转换成字符串
        String s1 = new String(bytes,6,6);
        System.out.println(s1);

        System.out.println("==========================");
        String s2="西部开源教育科技有限公司";
        //把字符串转成字符数组
        char[] chars = s2.toCharArray();

        //把字符数组转换成字符串
        String s3 = new String(chars,0,2);
        System.out.println(s3);
    }
}

6.valueOf() toUpperCase() toLowerCase() concat()

public class MyTest {
    public static void main(String[] args) {
        //ValueOf() 可以把多种类型，转换成字符串
        int num = 100;
        String s = num + "";
        System.out.println(String.valueOf(100));
        System.out.println(String.valueOf(false));
        System.out.println(String.valueOf(new char[]{'a','b','c'}));

        String s1 = "abc".toUpperCase();
        System.out.println(s1);
        System.out.println("ABC".toLowerCase());

        String str="abc"+"bbbb"+"ccc";

        String ss = "abc".concat("bbbb");
        System.out.println(ss);

        String concat = "aaa".concat("bbbb").concat("cccc").concat("asdfasdfadsfadsf");
        System.out.println(concat);
    }
}

public class MyTest {
    public static void main(String[] args) {
        //A:
        //案例演示:
        //需求：把一个字符串的首字母转成大写，其余为小写。(只考虑英文大小写字母字符)
        String s="aasdfeBDfeadfdEDFDFeadfeadfadf";
        String s1 = s.substring(0,1).toUpperCase().concat(s.substring(1).toLowerCase());
        System.out.println(s1);
    }
}

7.trim()

public class MyTest {
    public static void main(String[] args) {
        String s="     asdfasdddddd    fasdf   asdfasd    ";
        //删除两边的空格
        String s1 = s.trim();
        System.out.println(s1);
    }
}

8.replace()

public class MyTest {
    public static void main(String[] args) {
        String str = "特朗普和奥巴马都是美国总统";
        //一次替换一个字符
        String s = str.replace('特','*');
        System.out.println(s);

        String s1 = str.replace("特朗普","***").replace("奥巴马","***");
        System.out.println(s1);
    }
}

9.compareTo()

public class MyTest {
    public static void main(String[] args) {
        //boolean b = "abc".equals("abc");
        //比较字符串，按照字典顺序来比较的。比较不出来再按长度比
        int i = "abc".compareTo("abcedfdfdfdf");
        System.out.println(i);

        int num = "ABC".compareToIgnoreCase("abc");
        System.out.println(num);
    }
}

10.字符串

public class MyTest {
    public static void main(String[] args) {
         /* A:
        案例演示
        需求：把数组中的数据按照指定个格式拼接成一个字符串
        举例：
        int[] arr = {1, 2, 3};
        拼接结果：
        "[1, 2, 3]"*/

         int arr[] = {1,2,3,4,5,6};
        //遍历数组拼接字符串
        String str = "[";
        for(int i = 0;i < arr.length;i++){
            if(i == arr.length - 1){
                str+= arr[i] + "]";
            }else{
                str+= arr[i] + ",";
            }
        }
        System.out.println(str);
    }
}

public class MyTest {
    public static void main(String[] args) {
        /*  需求：统计大串中小串出现的次数
        举例:
        "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun" 中java出现了5次*/

        String maxStr = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagunjavajava";
        int count = 0;
        //第一次
        int index = maxStr.indexOf("java");
        while(index != -1){
            count++;
            maxStr = maxStr.substring(index+4);
            //重新给index赋值
            index = maxStr.indexOf("java");
        }
        System.out.println("有"+count+"个");
    }
}

11.StringBuffer

public class MyTest {
    public static void main(String[] args) {
        //StringBuffer可变字节序列，相当于一个容器，可以不断往容器中追加字符
        String s1="abc";
        String s2="abaa";
        String s3=s1+s2;

        /*StringBuffer()
        构造一个其中不带字符的字符串缓冲区，初始容量为16个字符。
         */
        StringBuffer sb = new StringBuffer();
        int capacity = sb.capacity();
        System.out.println(capacity);
        //可以指定容量
        StringBuffer buffer = new StringBuffer(100);
        System.out.println(buffer.capacity());

        //往容量中追加内容
        sb.append("abc");
        int length = sb.length();
        System.out.println(length);
    }
}

public class MyTest {
    public static void main(String[] args) {
        StringBuffer sb =new StringBuffer();
        //返回的还是容器本身
        StringBuffer b2 = sb.append(100);
        sb.append("2222").append(true).append("asdfasdf").append(3.25);
        System.out.println(b2 == sb);

        // StringBuffer 重写了toString()方法，把存在容器中的数据，转换成字符串返回
        String s = sb.toString();
        System.out.println(s);

        StringBuffer ssbb = new StringBuffer("abc");
        ssbb.append("asdfasdf").append("asdfasdfasdf").append("asdfasdfasdf");
        String s1 = ssbb.toString();
        System.out.println(s1);
    }
}

12.insert()

public class MyTest {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        sb.append("我爱你");
        //insert()王容器中指定位置插入内容，返回的还是原来那个容器
        sb.insert(0,"abc").insert(2,"你好");
        System.out.println(sb);
    }
}

13.deleteCharAt() delete()

public class MyTest {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        //根据索引删除某个字符，返回的还是容器本身
        sb.append("西部开源教育科技有限公司");
        sb.deleteCharAt(0);
        //根据起始索引和终止索引，删除一段内容，返回的还是容器本身
        sb.delete(0,5);     //含头不含尾
        System.out.println(sb);
    }
}

14.replace() reverse()

public class MyTest {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        //根据索引删除某个字符，返回的还是容器本身
        sb.append("西部开源教育科技有限公司");
        //根据起始索引和终止索引，替换容器中的某一部分内容，返回的还是容器本身，含头不含尾
        sb.replace(0,3,"好好学习");
        System.out.println(sb);
        //反转容器中的内容，返回的还是容器本身
        sb.reverse();
        System.out.println(sb);
    }
}

15.substring()

public class MyTest {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("abcasdfasdfasdf");
        String s = sb.substring(0);
        //根据起始索引和终止索引，截取容器中的内容返回为字符串，含头不尾
        String s1 = sb.substring(0,3);
        System.out.println(s);
        System.out.println(s1);
    }
}

16.StringBuffer —— String

public class MyTest {
    public static void main(String[] args) {
        //A:
        //String-- StringBuffer
        String str = "abc";
        //方式1
        StringBuffer sb = new StringBuffer(str);
        //方式2
        StringBuffer sb2 = new StringBuffer().append(str);
        //方式3
        StringBuffer sb3 = new StringBuffer().insert(0,str);

        //StringBuffer----String
        StringBuffer sb9 = new StringBuffer("hahaha");
        //方式1
        String s = sb9.toString();
        //方式2
        String s1 = sb9.substring(0);
        //方式3
        String s2 = new String(sb9);
    }
}

public class MyTest {
    public static void main(String[] args) {
       /* A:
        案例演示
        需求：把数组中的数据按照指定个格式拼接成一个字符串
        举例：
        int[] arr = {1, 2, 3};
        输出结果：
        "[1, 2, 3]"
        用StringBuffer的功能实现*/

        int[] arr = {1, 2, 3};
        StringBuffer sb = new StringBuffer("[");
        for (int i = 0; i < arr.length; i++) {
            if(i==arr.length-1){
                sb.append(arr[i]).append("]");
            }else{
                sb.append(arr[i]).append(",");
            }
        }
        String s = sb.toString();
        System.out.println(s);
    }
}

public class MyTest2 {
    public static void main(String[] args) {
        //引用类型，作为参数传递，形参的改变会影响实参。
        //基本类型作为参数传递，形参的改变，不影响实参。
        //字符串虽说是引用类型，但是他作为参数传递，属于值传递，跟基本数据类型一致。

        String str = "abc";
        test(str);
        System.out.println(str);  //abc
        StringBuffer sb = new StringBuffer("呵呵呵");
        test(sb);
        System.out.println(sb.toString());  //321呵呵呵
    }
    private static void test(StringBuffer sb){
        sb.append("123");
        sb.reverse();
    }
    private static void test(String s){
        s+="哈哈哈";
        System.out.println(s);  //abc哈哈哈
    }
}

17.StringJoiner()

public class MyTest2 {
    public static void main(String[] args) {
         /* A:
        案例演示
        需求：把数组中的数据按照指定个格式拼接成一个字符串
        举例：
        int[] arr = {1, 2, 3};
        输出结果：
        "[1, 2, 3]"
        用StringJoiner的功能实现*/
        int[] arr = {1, 2, 3};
        StringJoiner joiner = new StringJoiner(",","[","]");
        for (int i = 0; i < arr.length; i++) {
            joiner.add(arr[i] + "");
        }
        System.out.println(joiner.toString());
    }
}

LCYeezus

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java Scanner String

12.01_Scanner类的hasNextXxx() A：基本格式 hasNextXxx() 判断下一个是否是某种类型的元素，其中Xxx可以是 Int，Double等。如果需要判断是否含下一个字符串则可以省略Xxx nextXxx() 获取下一个输入项，Xxx的含义和上个方法中的Xxx 相同12.02_Scanner获取数据出现的小问题及解决...
复制链接

扫一扫