第十二天笔记

黑马程序员<a href="http://www.itheima.com" target="blank">java培训</a>

                                          第十二天笔记

1.Scanner

JDK5以后才出现的方法，文本扫描器，接收键盘输入

构造方法：

Public Scanner （(InputStream in）

 new Scanner(System.in)

System.in 运行结果是InputStream类的对象

HaaNextXXX()  XXX基本数据类型

可以判断出输入的数据类型

HasNextInt（） 判断出输入的是不是int类型，如果是返回true

 public int nextInt() 接收int类型数据

public String nextLine()  接收字符串类型数据

package lm.Scanner;

import java.util.Scanner;

public class ScannerDemo1 {

    /*
     * scanner 的实例
     */
    public static void main(String[] args) {
        getNotice2();
    }
   /*
    * Scanner 输入int 
   
    private static void getInt()
    {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入一个数字");
        int i=sc.nextInt();
        System.out.println(i);
    } */
    
    /*
     * Scanner 输入nextline
    
    
    private static void getLine()
    {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入一串字符：");
        String s=sc.nextLine();
        System.out.println(s);
    }
     */
    
    /*
     * 输入两个字符（1）
     
    private static void getDoubleLine()
    {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入一串字符：");
        String s1=sc.nextLine();
        System.out.println("请再次输入一串字符：");
        String s2=sc.nextLine();
        System.out.println("s1="+s1);
        System.out.println("s2="+s2);
    }
    */
    /*
     *输入字符和数字的注意事项(1)
    
      private static void getNotice()
    {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入一个数字：");
        int s1=sc.nextInt();
        System.out.println("请输入一串字符：");
        String s2=sc.nextLine();
        System.out.println("s1="+s1);
        System.out.println("s2="+s2);
     }
       */
        /*
         *输入字符和数字的注意事项(2)
         */
          private static void getNotice2()
        {
            Scanner sc=new Scanner(System.in);
            System.out.println("请输入一串字符：");
            String s2=sc.nextLine();
            System.out.println("请输入一个数字：");
            int s1=sc.nextInt();
            System.out.println("s1="+s1);
            System.out.println("s2="+s2);
         }
}

2.String 类的概述

String类是日后开发中频率最多的

字符串：完全表示日常生活中的数据。在JAVA中用“ ”引起来，字符串视为对象

类和对象，类描述对象，抽象表现形式

String类，描述字符串对象 String s=“  ”；

3.String类的构造方法

1.1    空参数 public String(){}

1.2    字节数组 public String(byte []  bytes)

使用平台默认字符集，windows中文版，默认字符编码表GBK，将字节数组中的每一数据，查询编码表对应的字符，显示出来数组中是负数，显示出来汉字，编码表中，汉字以负数形式存在，一个汉字用两个字节表示。

1.3    字符数组变成字符串 public String（char[]  ch）

3.3.1 都是将字节数组一部分变成字符串

  int offset 开始下标 int length 获取几个

不查编码表，将单个字符串，抽取出来，变成字符串

1.4    字节数 public String(byte [] bytes,int offset,int length)

3.4.1 不查询编码表，将单个字符串，抽取出来，变成字符串

 3.5 字符数组一部分变成字符串 public String(char[] ch,int offset,int length)

 3.5.1 int offset开始下标 int length 获取几个

都是将字符数组一部分变成字符串

Int offset 开始下标   int length 获取几个

package lm.String;
/**
 * 
 * @author Administrator
 * String类的获取方法
 *
 */
public class StringDemo {
 
    
    public static void main(String[] args) {
        method7();

    }
    /*
     * String substring(int start,int end)
     * 获取字符串的一部分，截取字符串
     */
     private static void method8()
     {
         String s="abcdefghi";
         String a=s.substring(3,6);
         System.out.println(a);
         
         
         String s2="abcdefgh";
         String s3=s2.substring(3);
         System.out.println(s3);
         
     }
    /*
     * int lashIndexOf(char ch,int fromIndex)
     * 返回指定字符在字符串中最后一次出现的下标
     * 反向查找，从指定下标开始
     */
     private static void method7()
     {
         String s="abcdefghi";
         int a=s.lastIndexOf("e",4);
         System.out.println(a);
         
     }
    /*
     * int lastIndexOf(char ch)
          返回指定字符在字符串中最后一次出现的下标
     * 反向查找
     */
     private static void method6()
     {
         String s="abcdefghi";
         int a=s.lastIndexOf('f');
         System.out.println(a);
         
     }
    
    /*
     * int indexOf(String s)
     * 返回指定的字符串第一次出现的下标
     * 从指定的下标开始找
     */
     private static void method5()
     {
         String s="abcdefghi";
         int a=s.indexOf("cde",7);
         System.out.println(a);
         
     }
    /*
     * int indexOf(String s)
     * 返回指定的字符串第一次出现的下标
     */
     private static void method4()
     {
         String s="abcdefghi";
         int a=s.indexOf("cde");
         System.out.println(a);
         
     }
    
    
    /*
     * int indexOf(char ch,int fromIndex)
     * 返回指定字符在字符串中第一次出现的下标
     * 从指定的下标开始查找
     */
     private static void method3()
     {
           String s1="abcdefgh";
           int a= s1.indexOf('c',4);
           System.out.println(a);
         
     }
    /*
     * int indexOf(char ch)
     * 返回指定字符在字符串中第一次出现的下标
     * 如果没有这个字符，返回负数
     */
       private static void method2()
       {
           String s1="abcdefgh";
           int a= s1.indexOf('c');
           System.out.println(a);
       }
    
    /*
     * char charAt(int index)
     * 返回指定下标上的单个字符
     */
     private static void method1()
     {
         String s1="abcdefgh";
         System.out.println(s1.charAt(1));//下标从0开始
   
        
         
     }
}

4.String类的面试题=====String的不变性

  String字符串是常量，创建好了，就不可改变

  String s=new String（”hello”）创建了两个对象

  一个是""字符串常量对象，另一个对象 new String()

  s指向的是new String对象

 String s = “hello”; 创建了一个对象"" s 指向""对象

 "" 和null的区别

  "" 字符串对象，可以调用String类的方法

  null 空常量，调用方法出现空指针异常

5. String类的常用方法--判断方法，返回值boolean 

5.1 boolean equals(Object obj) String类继承Object，重写equals方法. 比较两个字符串的具体内容是否相等，如果相等返回true

5.2 boolean equalsIgnoreCase(String s) 判断两个字符串是否相等,忽略大小写

5.3 boolean contains(String s)判断一个字符串中，是否包含另一个字符串,如果完全包含，返回true

5.4 boolean startsWith(String s)判断一个字符串是否以另一个字符串开头.如果完全是开头，返回true

5.5 boolean endsWith(String s)判断一个字符串是否以另一个字符串结尾,如果完全是结尾，返回true

5.6 boolean isEmpty() 判断一个字符串中是否有字符，如果没有字符返回true

package lm.String;

/**
 * 
 * @author Administrator
 * String 类判断方法
 * 返回值都是boolean
 */
public class StringDemo2 {
    public static void main(String[] args) {
        method7();
        
    }
    /*
     * isEmpty()
     * 判断一个字符串中是否有内容，没有返回true
     */
    private static void method7()
    {
        String s=" "; 
        boolean b=s.isEmpty();
        System.out.println(b);
    }
    
    /*
     * endsWith(String s)
     * 判断一个字符串是否以另一个字符串结尾
     */
    private static void method6()
    {
        String s="abjavacdefgh"; 
        boolean b=s.endsWith("fgh");
        System.out.println(b);
    }
    /*
     * startsWith(String s,int)
     * 判断一个字符串从第几个开始是以另一个字符串开头
     */
    private static void method5()
    {
        String s="abjavacdefgh"; 
        boolean b=s.startsWith("java",2);
        System.out.println(b);
    }
    
    
    /*
     * startsWith(String s)
     * 判断一个字符串是否以另一个字符串开头
     */
    private static void method4()
    {
        String s="abjavacdefgh"; 
        boolean b=s.startsWith("a");
        System.out.println(b);
    }
    
    /*
     * contains(String s)
     * 判断一个字符串是否完全包含另一个字符串
     */
    
    private static void method3()
    {
        String s="abjavacdefgh"; 
        boolean b=s.contains("java");
        System.out.println(b);
    }
    /*
     * equalsIgnoreCase(String s)
     * 比较两个字符串的内容是否相等，忽略大小写
     */
    private static void method2()
    {

        String s1="abCdDf";
        String s2="abcdef";
        if(s1.equalsIgnoreCase(s2))
        {
            System.out.println("字符串相等");
        }
        else
        {
            System.out.println("字符串不相等");
        }
        System.out.println(s1==s2);
        System.out.println(s1.equals(s1));
    }
    /*
     * equals方法 ，重写Object类
     * 比较字符串的具体内容
     */
    private static void method1()
    {
        String s1="abcdef";
        String s2="abcdef";
        if(s1.equals(s2))
        {
            System.out.println("字符串相等");
        }
        System.out.println(s1==s2);
        System.out.println(s1.equals(s2));
    }
    
}

6. 利用字符串方法案例

  检测用户输入的内容是否和预定的内容一样

  程序预定2个字符串，让用户输入2个字符串，判断是不是2个都完全一样

  用户名，密码

  Scanner  nextLine  equals方法

7. String类的获取方法

 7.1 int length() 返回字符串中的字符个数

     String类里面，有一个final private 字符数组，length()方法，返回的就是数组长度

 7.2 char charAt(int index) 返回指定索引上的单个字符   

  如果索引不存在，运行时期出现 java.lang.StringIndexOutOfBoundsException:

 7.3 int indexOf(char ch) 返回指定的字符在字符串中第一次出现的下标

  如果没有这个字符，返回负数

 7.4 int indexOf(char ch,int fromIndex)返回指定的字符在字符串中第一次出现的下标

   从指定的下标开始查找

 7.5 int indexOf(String s)返回指定的字符串，在一个字符串中第一次出现的下标

 7.6 int indexOf(String s,int fromIndex)返回指定的字符串，在一个字符串中第一次出现的下标,从指定的下标开始查找

 7.7 int lastIndexOf(char ch) 返回指定字符在字符串中最后一次出现的下标,反向查找

 7.8 int lastIndexOf(char ch,int fromIndex) 返回指定字符在字符串中最后一次出现的下标,反向查找，从指定下标开始查找，从指定下标，开始向前找

7.9 String substring(int start,int end) 获取字符的一部分，截取字符串 ,返回一个新的字符串 ,包含头，不包含尾

7.10 String substring(int start) 获取字符串的一部分，截取字符串,从指定下标开始，后面的全要

8. 字符串的练习

  A . 遍历字符串，获取每一个字符

     char charAt(int 索引) 循环的次数字符串的length()方法决定

  B. 统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)

  waeWWs42rd#D54YHRty

  遍历思想+计数器，3个计数器

  如何确定一个字符，是小写，大写还是数字

  一种ASCII码  65-90  97-122  48-57

  字符做运算= > < == 字符char 默认提升为int类型

  'a' > 'b'

9. String类转换方法

  9.1 byte[] getBytes() 将字符串转成字节数组，查询本机默认编码表 GBK

      构造方法，相反的运算

  9.2 char[] toCharArray() 将字符串转成字符数组，不查询编码表

  9.3 String toUpperCase() 将字符串转成大写字母，全转

  9.4 String toLowerCase() 将字符串转成小写字母，全转

  9.5 String concat(String s)连接字符串

     "ab".concat("cd")  "ab"+"cd"

  9.6 static String valueOf(任意类型) 将任意类型转成字符串

package lm.String;
/**
 *  String类的转换功能
 * @author Administrator
 *
 */
public class StringDemo3 {
    public static void main(String[] args) {
        method5();
        
    }
    /*
     * String substring(int start,int end)
     * 获取字符串的一部分，截取字符串
     */
     private static void method5()
     {
         String s1="abcdef";
         s1= s1.substring(1, s1.length()-1);
         System.out.println(s1);
          
         
     }    
    /*
     * String concat(String s)
     * 连接字符串，返回新的字符串
     */
     private static void method4()
     {
         String s1="abcdef";
         s1= s1.concat(".java");
         System.out.println(s1);
          
         
     }
    /*
     * String toUpperCase()字符串转成大写
     * String toLowerCase()字符串转成小写
     */
     private static void method3()
     {
         String s1="abcdef";
         System.out.println(s1.toUpperCase());
         String s2="ABCDEF";
         System.out.println(s2.toLowerCase());
         
         
     }
    
    
    /*
     * char[] toCharArray()
     * 将字符串转成字符数组，不查询编码表
     */
     private static void method2()
     {
         String s="abcdefg";
         char[] ch=s.toCharArray();
         System.out.println(ch);//char 字符自己进行遍历
     }
    
    /*
     * 
     * byte[] getBytes()
     * 将字符串转成字节数组
     * 查编码表
     */
    
   private static void method1()
   {
       String s="abcdeg";
       byte[] bytes=s.getBytes();
       for(int i = 0 ; i < bytes.length ; i++){
            System.out.println(bytes[i]);
        }
   }
}

10. 把一个字符串的首字母转成大写，其余为小写。(只考虑英文大小写字母字符)

  思想1：

     直接使用String类的，大小写转换功能

     charAt(0)  toUpperCase

     剩下 substring(1)toLowerCase

  思想2：

     遍历每个字符，单独自己去转换

     'a'-32 = 'A'

11. String类的其他方法

  11.1 String[] split(String s)按照正则表达式，切割此字符串

    "abd yerf5 rf 5tu"

  11.2 String replace(char oldChar , char newChar)替换字符串中的字符

    原始字符串不变，返回新字符串

  11.3 String replace(String oldString , String newStrng)替换字符串中的字符串

    原始字符串不变，返回新字符串

11.4 String trim() 去掉字符串两端的空格，字符串中间有空格，不能去掉

   登录账户的时候，输入用户名

  11.5 int compareTo(String) 比较两个字符串，按照字典顺序abcd (对象的自然顺序)

    一个对象有没有自然顺序，看这个类是否实现Comparable接口

    "qc".compareTo("de")

    比较的结果是负数，说明调用者小于参数

    比较的结果是正数，说明调用者大于参数

    比较的结果是0   ，说明调用者等于参数

    String类继承Object，同时实现了Comparable接口，compareTo重写接口的抽象方法

package lm.String;

/**
 * 
 * @author Administrator String类的其他功能
 */

public class StringDemo4 {

    public static void main(String[] args) {
        method5();
    }

    /*
     * String[] split(String s) 根据传递的内容，切割字符串 切割下来的内容，存储到字符串数组中
     */
    private static void method5()
    {
        String s1="how old are you";
        String [] st=s1.split(" ");
        for (int i = 0; i < st.length; i++) {
            System.out.print("st["+i+"]="+st[i]+" ");
        }
        
       System.out.println("===================");
       String s2="192.168.25.34";
       String [] st1=s2.split("\.");
       for (int i = 0; i < st1.length; i++) {
            System.out.print("st1["+i+"]="+st1[i]+" ");
        }
    }
    
     

    /*
     * int compareTo(String s) 按照字典顺序比较两个字符串(字符串的对象的自然顺序)
     */
    private static void method4() {
        String s1 = "abc";
        String s2 = "abc";
        System.out.println(s1.compareTo(s2));
    }

    /*
     * String trim() 去掉字符串两端空格
     */
    private static void method3() {
        String s1 = "   how are you   ";
        System.out.println(s1);
        s1 = s1.trim();
        System.out.println(s1);
    }

    /*
     * String replace(老字符，新字符) 替换字符串
     */
    private static void method2() {
        String s1 = "how are you";
        s1 = s1.replace('o', 'M');
        System.out.println(s1);
    }

    /*
     * String replace(老字符，新字符) 替换字符串
     */

    private static void method1() {
        String s1 = "how are you";
        s1 = s1.replace("are", "MMMMM");
        System.out.println(s1);
    }

}