Java学习笔记4

Eclipse中快捷键的使用

A:新建 ctrl + n
B:格式化 ctrl+shift+f
C:导入包 ctrl+shift+o
D:注释 ctrl+/,ctrl+shift+/,ctrl+shift+\
E:代码上下移动选中代码alt+上/下箭头
F:查看源码选中类名(F3或者Ctrl+鼠标点击)
G:查找具体的类 ctrl + shift + t
H:查找具体类的具体方法 ctrl + o
I:给建议 ctrl+1,根据右边生成左边的数据类型,生成方法
J:删除代码 ctrl + d
K:抽取方法alt + shift + m
L:改名alt + shift + r

Eclipse中如何提高开发效率

alt + shift + s

A:自动生成构造方法
B:自动生成get/set方法

Eclipse中如何生成jar包并导入到项目中

A:jar是什么?
- jar是多个class文件的压缩包。
B:jar有什么用?
- 用别人写好的东西
C:打jar包
- 选中项目--右键--Export--Java--Jar--自己指定一个路径和一个名称--Finish
D:导入jar包
- 复制到项目路径下并添加至构建路径

API概述

A:API(Application Programming Interface)
- 应用程序编程接口
B:Java API
- 就是Java提供给我们使用的类，这些类将底层的实现封装了起来，
- 我们不需要关心这些类是如何实现的，只需要学习这些类如何使用。

Object类的概述

A:Object类概述
- 类层次结构的根类
- 所有类都直接或者间接的继承自该类
B:构造方法
- public Object()
- 回想面向对象中为什么说：
- 子类的构造方法默认访问的是父类的无参构造方法

Object类的hashCode()方法

A:案例演示
* public int hashCode()
* a:返回该对象的哈希码值。默认情况下，该方法会根据对象的地址来计算。
* b:不同对象的，hashCode()一般来说不会相同。但是，同一个对象的hashCode()值肯定相同。

package com.heima.object;

import com.heima.bean.Student;

public class Demo1_HashCode {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Object obj1 = new Object();
        int hashCode = obj1.hashCode();
        System.out.println(hashCode);
        
        Student s1 = new Student("张三",23);
        Student s2 = new Student("李四",24);
        
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
    }

}

Object类的getClass()方法

package com.heima.object;

import com.heima.bean.Student;

public class Demo2_GetClass {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Student s = new Student("张三",23);
        Class clazz = s.getClass();   //获取该对象的字节码文件
        String name = clazz.getName();  //获取名称
        System.out.println(name);
    }

}

Object类的toString()方法

A:案例演示
- public String toString()
- a:返回该对象的字符串表示。
b:它的值等于：
* getClass().getName() + "@" + Integer.toHexString(hashCode())
* 左边：类名。中间：@。右边：hashCode的十六进制表现形式。
- c:由于默认情况下的数据对我们来说没有意义，一般建议重写该方法。
  toString方法的作用：可以更方便的显示属性值，而getXxx方法是为了获取值，可以显示也可以赋值，或做其他操作

        public Stirng toString() {
            return name + "," + age;
        }

B:最终版
- 自动生成 aLT+SHIFT+S +S

package com.heima.object;

import com.heima.bean.Student;

public class Demo3_ToString {

    /**
     * @param args
     * com.heima.bean.Student@97d01f

     */
    public static void main(String[] args) {
        Student s = new Student("张三",23);
//      String str = s.toString();
//      System.out.println(str);
        System.out.println(s.toString());
        System.out.println(s);     //如果直接打印对象的引用，会默认调用toString方法
        //即会先判断是否为null，非null才会调用toString()方法
        System.out.println("我的姓名是：" + s.getName() +",我的年龄是：" + s.getAge());
        
    }

}

Object类的equals()方法

A:案例演示
- a:指示其他某个对象是否与此对象“相等”。
- b:默认情况下比较的是对象的引用是否相同。
- c:由于比较对象的引用没有意义，一般建议重写该方法。因为在开发中我们通常比较的是对象中的属性值，如果属性值相同，我们认为应该返回true。

package com.heima.object;

import com.heima.bean.Student;

public class Demo4_Equlas {

    /**
     * @param args
     *  public boolean equals(Object obj) {
            return (this == obj);
        }
     */
    public static void main(String[] args) {
        Student s1 = new Student("张三", 23);
        Student s2 = new Student("张三", 23);
        boolean b = s1.equals(s2);
        System.out.println(s1 == s2); 
        System.out.println(b);   //重写之后比较的是对象中的属性值
    }

}

==号和equals方法的区别

==是一个比较运算符号,既可以比较基本数据类型,也可以比较引用数据类型,基本数据类型比较的是值,引用数据类型比较的是地址值
equals方法是一个方法,只能比较引用数据类型,所有的对象都会继承Object类中的方法,如果没有重写Object类中的equals方法,equals方法和==号比较引用数据类型无区别,重写后的equals方法比较的是对象中的属性
有些类（像String、Integer等类）对equals进行了重写，但是没有对equals进行重写的类（比如我们自己写的类）就只能从Object类中继承equals方法，其equals方法与==就也是等效的，除非我们在此类中重写equals。

package com.heima.bean;

public class Student {
    private String name;
    private int age;
    public Student() {
        super();
        
    }
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    /*@Override
    public String toString() {
        
        return "我的姓名是：" + name + ",我的年龄是：" + age;
    }*/
    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }
    @Override
    //重写equals方法
    public boolean equals(Object obj) {
        Student s = (Student)obj;
        return this.name.equals(s.name) && this.age == s.age;
    }
    
    
}

Scanner的概述和方法介绍

A:Scanner的概述

B:Scanner的构造方法原理
- Scanner(InputStream source)
- System类下有一个静态的字段：
  - public static final InputStream in; 标准的输入流，对应着键盘录入。
C:一般方法
- hasNextXxx() 判断是否还有下一个输入项,其中Xxx可以是Int,Double等。如果需要判断是否包含下一个字符串，则可以省略Xxx
- nextXxx() 获取下一个输入项。Xxx的含义和上个方法中的Xxx相同,默认情况下，Scanner使用空格，回车等作为分隔符

package com.heima.scanner;

import java.util.Scanner;

public class Demo1_Scanner {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);   //键盘录入
        //int i = sc.nextInt();                    //键盘录入整数存储在i中
        //System.out.println(i);
        if(sc.hasNextInt()) {
            int i = sc.nextInt();
            System.out.println(i);
        }else {
            System.out.println("输入的类型错误");
        }
    }
}

Scanner获取数据出现的小问题及解决方案

A:两个常用的方法：
- public int nextInt():获取一个int类型的值
- public String nextLine():获取一个String类型的值
B:案例演示
- a:先演示获取多个int值，多个String值的情况
- b:再演示先获取int值，然后获取String值出现问题
- c:问题解决方案
  - 第一种：先获取一个数值后，在创建一个新的键盘录入对象获取字符串。
  - 第二种：把所有的数据都先按照字符串获取，然后要什么，你就对应的转换为什么。(后面讲)

package com.heima.scanner;

import java.util.Scanner;

public class Demo2_Scanner {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        /*
         * nextInt()是键盘录入整数的方法，当我们录入10的时候
         * 其实在键盘上录入的是10和\r\n，nextInt()方法只获取10就结束了
         * nextLine()是键盘录入字符串的方法，可以接收任意类型，当他遇到\r\n就表示一行结束了。
         */
        System.out.println("请输入一个整数：");
        int i = sc.nextInt();
        System.out.println("请输入第二个字符串");
        String line2 = sc.nextLine();
        System.out.println("i = " + i + ", line2 = " + line2);
        /*解决方案
         * 1.创建两次对象，但是浪费空间
         * 2.键盘录入的都是字符串，都用nextLine()方法，后面我们会学习将整数字符串转换成整数的方法。
         */
        int i2 = sc.nextInt();
        Scanner sc2 = new Scanner(System.in);
        String line = sc2.nextLine();
        System.out.println(i2);
        System.out.println(line);
        
    }

String类的概述

A:String类的概述
- 通过JDK提供的API，查看String类的说明
- 可以看到这样的两句话。
  - a:字符串字面值"abc"也可以看成是一个字符串对象。
  - b:字符串是常量，一旦被赋值，就不能被改变。

package com.heima.string;

public class Demo1_String {

    /**
     * @param args
     */
    public static void main(String[] args) {
        String str = "abc";          //"abc"可以看成一个字符串对象
        str = "def";         //当把"def"赋值给str，原来的"abc"就变成了垃圾
        System.out.println(str); //String类重写了toString方法返回的是该对象本身

    }

}

String类的构造方法

A:常见构造方法
- public String():空构造
- public String(byte[] bytes):把字节数组转成字符串
- public String(byte[] bytes,int index,int length):把字节数组的一部分转成字符串
- public String(char[] value):把字符数组转成字符串
- public String(char[] value,int index,int count):把字符数组的一部分转成字符串
- public String(String original):把字符串常量值转成字符串
B:案例演示
- 演示String类的常见构造方法

package com.heima.string;

public class Demo2_Stringcon {

    /**
     * @param args
     */
    public static void main(String[] args) {
        String s1 = new String();
        System.out.println(s1);
        
        byte[] arr1 = {97,98,99};
        String s2 = new String(arr1);  
        System.out.println(s2);
        
        byte[] arr2 ={97,98,99,100,101,102};
        String s3 = new String(arr2,2,3); //2索引开始转换3个
        System.out.println(s3);
        
        char[] arr3 = {'a','b','c','d','e'};
        String s4 = new String(arr3);
        System.out.println(s4);
        
        String s5 = new String(arr3,1,3); //1索引转换3个
        System.out.println(s5);
        
        String s6 = new String("heima");
        System.out.println(s6);

    }

}

面试题

package com.heima.string;

public class Demo3_String {

    /**
     * * 1.判断定义为String类型的s1和s2是否相等
    * String s1 = "abc";
    * String s2 = "abc";
    * System.out.println(s1 == s2);                     
    * System.out.println(s1.equals(s2));        
* 2.下面这句话在内存中创建了几个对象?
    * String s1 = new String("abc");            
* 3.判断定义为String类型的s1和s2是否相等
    * String s1 = new String("abc");            
    * String s2 = "abc";
    * System.out.println(s1 == s2);     
    * System.out.println(s1.equals(s2));
* 4.判断定义为String类型的s1和s2是否相等
    * String s1 = "a" + "b" + "c";
    * String s2 = "abc";
    * System.out.println(s1 == s2);     
    * System.out.println(s1.equals(s2));
* 5.判断定义为String类型的s1和s2是否相等
    * String s1 = "ab";
    * String s2 = "abc";
    * String s3 = s1 + "c";
    * System.out.println(s3 == s2);
    * System.out.println(s3.equals(s2));
     */
    public static void main(String[] args) {
        String s1 = "ab";
        String s2 = "abc";
        String s3 = s1 + "c";
        System.out.println(s3 == s2);       //false
        System.out.println(s3.equals(s2));  //true
    }

    private static void demo4() {
        //byte b = 3 + 4;            //编译的时候已经是7，把7赋值给b
        String s1 = "a" + "b" + "c"; //编译的时候已经是"abc"
        String s2 = "abc";
        System.out.println(s1 == s2);    //true,Java有常量优化机制 
        System.out.println(s1.equals(s2));     //true
    }

    private static void demo3() {
        String s1 = new String("abc");      //记录的是堆内存中的地址值  
        String s2 = "abc";                  //记录的是常量池中的地址值
        System.out.println(s1 == s2);       //false
        System.out.println(s1.equals(s2));  //true
    }

    private static void demo2() {
        //创建两个对象，一个在常量池中，一个在堆内存中
        String s1 = new String("abc");
        System.out.println(s1);
    }
    
    private static void demo1() {
        String s1 ="abc";
        String s2 ="abc";
        System.out.println(s1 == s2);       //true
        System.out.println(s1.equals(s2));  //true
        
    }

}

String面试题1.png

String面试题2.png

String面试题5.png

String类的判断功能

package com.heima.string;

public class Demo4_StringMethod {

    /**
     * * A:String类的判断功能
    * boolean equals(Object obj):比较字符串的内容是否相同,区分大小写
    * boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
    * boolean contains(String str):判断大字符串中是否包含小字符串
    * boolean startsWith(String str):判断字符串是否以某个指定的字符串开头
    * boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾
    * boolean isEmpty():判断字符串是否为空。
    * 
    * ""和null的区别
    * ""是字符串常量，同时也是一个String类的对象，既然是对象当然可以调用String类中的方法
    * null是空常量,不能调用任何的方法，否则会出现空指针异常,null常量可以给任意的引用数据类型赋值。
     */
    public static void main(String[] args) {
        String s1 = "heima";
        String s2 = "";
        String s3 = null;
        
        System.out.println(s1.isEmpty());
        System.out.println(s2.isEmpty());
        //System.out.println(s3.isEmpty()); 
    }

    private static void demo2() {
        String s1 = "我爱heima,哈哈";
        String s2 = "heima";
        String s3 = "baima";
        String s4 = "我爱";
        String s5 = "哈哈";
        
        System.out.println(s1.contains(s2));  //判断是否包含传入的字符
        System.out.println(s1.contains(s3));
        
        System.out.println(s1.startsWith(s4));  //判断是否以传入的字符串开头
        System.out.println(s1.startsWith(s5));
        
        System.out.println(s1.endsWith(s4));   //判断是否以传入的字符串结尾
        System.out.println(s1.endsWith(s5));
    }

    private static void demo1() {
        String s1 = "heima";
        String s2 = "heima";
        String s3 = "HeiMa";
        
        System.out.println(s1.equals(s2));    //true
        System.out.println(s2.equals(s3));    //false
        System.out.println(s1.equalsIgnoreCase(s3));   //不区分大小写
    }

}

模拟用户登录

如果是字符串常量和字符串变量比较，通常都是字符串常量调用方法，将变量当作参数传递，防止空指针异常。

String类的获取功能

A: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):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。
- lastIndexOf
- String substring(int start):从指定位置开始截取字符串,默认到末尾。
- String substring(int start,int end):从指定位置开始到指定位置结束截取字符串。

package com.heima.string;

public class Demo5_StringMethod {

    /**
     * @param args
     */
    public static void main(String[] args) {
        String s = "woaiheima";
        s.substring(4);
        System.out.println(s);  //注意s和s.substring
    }

    private static void demo4() {
        String s1 = "heimawudi";
        String s2 = s1.substring(5);
        System.out.println(s2);
        
        String s3 = s1.substring(0, 5); //包含头不包含尾，左闭又开
        System.out.println(s3);
    }

    private static void demo3() {
        String s1 = "woaiheima";
        int index1 = s1.indexOf('a',3);  //从指定位置(包含指定位置)开始向后找
        System.out.println(index1);
        
        int index2 = s1.lastIndexOf('a');   //从后向前找
        System.out.println(index2);
        
        int index3 = s1.lastIndexOf('a',7); //从指定位置向前找
        System.out.println(index3);
    }

    private static void demo2() {
        String s1 = "heima";
        int index = s1.indexOf('a');  //参数接收的是int类型,传递char类型会自动提升
        System.out.println(index);
        
        int index2 = s1.indexOf('z'); //如果不存在，返回-1
        System.out.println(index2);
        
        int index3 = s1.indexOf("ma");//获取字符串中第一个字符出现的位置
        System.out.println(index3);
        
        int index4 = s1.indexOf("ia");
        System.out.println(index4);
    }

    private static void demo1() {
        int[] arr = {11,22,33};
        System.out.println(arr.length);   //数组中的length是属性
        String s1 = "heima";
        System.out.println(s1.length());
        String s2 = "你要减肥，造吗？";
        System.out.println(s2.length());  //length()是一个方法，获取的是所有字符的个数
        
        char c = s2.charAt(5);
        System.out.println(c);    //根据索引获取对应位置的字符
        char c2 = s2.charAt(10);
        System.out.println(c2);   //StringIndexOutOfBoundsException字符串索引越界异常
    }

}

字符串的遍历

package com.heima.test;

public class Test2 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        String s = "heima";
        
        for(int i = 0; i < s.length(); i++) {
            System.out.println(s.charAt(i));
        }

    }

}

统计不同类型字符个数

package com.heima.test;

public class Test3 {

    /**
     * * 需求：统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数,其他字符出现的次数。
     * ABCDEabcd123456!@#$%^
     */
    public static void main(String[] args) {
        String s = "ABCDEabcd123456!@#$%^";
        int big = 0;
        int small = 0;
        int num = 0;
        int other = 0;
        
        for(int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if(c >= 'A' && c <= 'Z') {
                big++;
            }else if(c >= 'a' && c <= 'z') {
                small++;
            }else if(c >= '0' && c <= '9') {
                num++;
            }else {
                other++;
            }
        }
        System.out.println("大写字母" + big + "小写字母" + small +"数字字符" + num +"其他" + num);
    }

}

String类的转换功能

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

package com.heima.string;

import com.heima.bean.Person;

public class Demo6_StringMethod {

    /**
     * @param args
     */
    public static void main(String[] args) {
        String s1 = "heiMA";
        String s2 = "chengxuYUAN";
        String s3 = s1.toLowerCase();
        String s4 = s2.toUpperCase();
        
        System.out.println(s3);
        System.out.println(s4);
        
        System.out.println(s3 + s4);        //用+拼接字符串更强大，可以用字符串与任意类型相加
        System.out.println(s3.concat(s4));  //concat方法调用的和传入的都必须是字符串
    }

    private static void demo3() {
        char[] arr = {'a','b','c'};
        String s = String.valueOf(arr);    //底层是由String类的构造方法完成的
        System.out.println(s);
        
        String s2 = String.valueOf(100);    //将100转化为字符串
        System.out.println(s2);
        
        Person p1 =new Person("张三",23);
        System.out.println(p1);
        String s3 = String.valueOf(p1);     //调用的是对象的toString方法
        System.out.println(s3);
    }

    private static void demo2() {
        String s = "heima";
        char[] arr = s.toCharArray();
        
        for (int i =0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }

    private static void demo1() {
        String s1 = "abc";
        byte[] arr = s1.getBytes();
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        
        String s2 = "你好你好";
        byte[] arr2 = s2.getBytes();   //通过gbk码表将字符串转换成字节数组
        for (int i = 0; i < arr2.length; i++) {  //编码：把我们看得懂的变成计算机看得懂的
            System.out.print(arr2[i] + " ");     //gbk码表一个中文代表两个字节
        }                                       //gbk码表特点，中文的第一个字节肯定是负数
    }

}

链式编程

package com.heima.test;

public class Test4 {

    /**
     * * 需求：把一个字符串的首字母转成大写，其余为小写。(只考虑英文大小写字母字符)
     * 链式编程：只要保证每次调用完方法返回的是对象，就可以继续调用
     */
    public static void main(String[] args) {
        String s = "woaiHEImaniaima";
        String s2 = s.substring(0,1).toUpperCase().concat(s.substring(1).toLowerCase());
        System.out.println(s2);
    }

}

把数组转成字符串

package com.heima.test;

public class Test5 {

    /**
     * * 需求：把数组中的数据按照指定个格式拼接成一个字符串
     * 举例：
     * 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++) {
            if(i == arr.length - 1) {
                s = s + arr[i] + "]";
            }else {
                s = s + arr[i] + ", ";
            }
        }
        System.out.println(s);
    }
}

String类的其他功能

A:String的替换功能及案例演示
- String replace(char old,char new)
- String replace(String old,String new)
B:String的去除字符串两空格及案例演示
- String trim()
C:String的按字典顺序比较两个字符串及案例演示
- int compareTo(String str)(暂时不用掌握)
- int compareToIgnoreCase(String str)(了解)

package com.heima.string;

public class Demo7_StringMethod {

    /**
     * @param args
     */
    public static void main(String[] args) {
        String s1 = "a";
        String s2 = "aaaa";
        
        int num = s1.compareTo(s2);    //按照码表值比较
        System.out.println(num);

        String s3 = "黑";
        String s4 = "马";
        int num2 = s3.compareTo(s4);
        System.out.println('黑' + 0);    //查找的是unicode码表值
        System.out.println('马' + 0);
        System.out.println(num2);
        
        String s5 = "heima";
        String s6 = "HEIMA";
        int num3 = s5.compareTo(s6);
        System.out.println(num3);
        
        int num4 = s5.compareToIgnoreCase(s6);
        System.out.println(num4);
        /*
         * public int compare(String s1, String s2) {
            int n1 = s1.length();
            int n2 = s2.length();
            int min = Math.min(n1, n2);
            for (int i = 0; i < min; i++) {
                char c1 = s1.charAt(i);
                char c2 = s2.charAt(i);
                if (c1 != c2) {
                    c1 = Character.toUpperCase(c1);
                    c2 = Character.toUpperCase(c2);
                    if (c1 != c2) {
                        c1 = Character.toLowerCase(c1);
                        c2 = Character.toLowerCase(c2);
                        if (c1 != c2) {
                            // No overflow because of numeric promotion
                            return c1 - c2;
                        }
                    }
                }
            }
            return n1 - n2;
        }
        */
    }

    private static void demo2() {
        String s = "   hei   ma   ";
        String s2 = s.trim();
        System.out.println(s2);
    }

    private static void demo1() {
        String s = "heimaei";
        String s2 = s.replace('i', 'o'); //用o替换i
        System.out.println(s2);
        
        String s3 = s.replace('z', 'o');   //若不存在，则不变。
        System.out.println(s3);
        
        String s4 = s.replace("ei", "ao");
        System.out.println(s4);
    }

}

字符串反转

package com.heima.test;

import java.util.Scanner;

public class Test6 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();
        
        char[] arr = line.toCharArray();
        
        String s ="";
        for(int i = arr.length-1; i >=0; i--) {
            s = s + arr[i];
        }
        System.out.println(s);

    }

}

在大串中查找小串出现的次数

package com.heima.test;

public class Test7 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        String max = "woaiheima,heimabaima,wulunheimahaishibaima,zhaodaohaoma";
        
        String min = "heima";
        
        int count = 0;
        
        int index = 0;
        
        while((index = max.indexOf(min)) != -1) {
            count++;    
            max = max.substring(index + min.length());  //截取已经找完的
        }
        
        System.out.println(count);

    }

}

大串中获取小串的次数.png

StringBuffer类的概述

A:StringBuffer类概述
- 线程安全的可变字符序列
B:StringBuffer和String的区别
- String是一个不可变的字符序列
- StringBuffer是一个可变的字符序列

StringBuffer类的构造方法

A:StringBuffer的构造方法：
- public StringBuffer：无参构造方法
- public StringBuffer(int capacity):指定容量的字符串缓冲区对象
- public StringBuffer(String str):指定字符串内容的字符串缓冲区对象
B:StringBuffer的方法:
- public int capacity():返回当前容量。理论值
- public int length():返回长度（字符数）。实际值

package com.heima.stringbuffer;

public class Demo1_Stringbuffer {

    /**
     * @param args
     */
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        System.out.println(sb.length());        //容器中的字符个数，实际值
        System.out.println(sb.capacity());      //容器的初始容量，理论值
        
        StringBuffer sb2 = new StringBuffer(10);
        System.out.println(sb2.length());
        System.out.println(sb2.capacity());
        
        StringBuffer sb3 = new StringBuffer("heima");
        System.out.println(sb3.length());       //实际字符的个数
        System.out.println(sb3.capacity());     //字符串的length + 初始容量
    }

}

StringBuffer的添加功能

A:StringBuffer的添加功能
- public StringBuffer append(String str):
  - 可以把任意类型数据添加到字符串缓冲区里面，并返回字符串缓冲区本身
- public StringBuffer insert(int offset,String str):
  - 在指定位置把任意类型的数据插入到字符串缓冲区里面，并返回字符串缓冲区本身

package com.heima.stringbuffer;

public class Demo2_Stringbuffer {

    /**
     * @param args
     */
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("123");//123heima
        sb.insert(3,"heima");//在指定位置添加元素，如果没有指定位置的索引就会报索引越界异常
        System.out.println(sb);//例子中是012有值，3号位置正好可以插入。若只有01位置有值就会报错。
    }

    private static void demo1() {
        StringBuffer sb = new StringBuffer();
        StringBuffer sb2 = sb.append(true);
        StringBuffer sb3 = sb.append("heima");
        StringBuffer sb4 = sb.append(100);
        /*StringBuffer是字符串缓冲区，当new的时候是在堆内存创建一个对象，底层是一个长度为16
        的字符数组，当调用添加的方法时，不会再重新创建对象，在不断向原缓冲区添加字符
        */
        System.out.println(sb.toString());//StringBuffer类中重写了toString方法，显示的是对象中的属性值
        System.out.println(sb2.toString());
        System.out.println(sb3.toString());
        System.out.println(sb4.toString());
        /*trueheima100
        trueheima100
        trueheima100
        trueheima100*/
    }

}

StringBuffer的删除功能

A:StringBuffer的删除功能
- public StringBuffer deleteCharAt(int index):
  - 删除指定位置的字符，并返回本身
- public StringBuffer delete(int start,int end):
  - 删除从指定位置开始指定位置结束的内容，并返回本身

package com.heima.stringbuffer;

public class Demo3_StringBuffer {

    /**
     * @param args
     */
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        //sb.deleteCharAt(5);//当缓冲区中这个索引上没有元素的时候就会报StringIndexOutOfBoundsException
        sb.append("heima");
        //sb.deleteCharAt(4); //根据索引删除掉索引位置上对应的字符
        sb.delete(0, 2);      //删除的时候是包含头，不包含尾
        sb.delete(0, sb.length()); //清空缓冲区
        System.out.println(sb);
    }

}

StringBuffer的替换和反转

A:StringBuffer的替换功能
- public StringBuffer replace(int start,int end,String str):
  - 从start开始到end用str替换
B:StringBuffer的反转功能
- public StringBuffer reverse():
  - 字符串反转

package com.heima.stringbuffer;

public class Demo4_StringBuffer {

    /**
     * @param args
     */
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("heima");
        sb.replace(0, 3, "bai");     //替换
        System.out.println(sb);
        
        sb.reverse();    //反转
        System.out.println(sb);   
    }

}

Stringbuffer的截取功能

A:StringBuffer的截取功能
- public String substring(int start):
  - 从指定位置截取到末尾
- public String substring(int start, int end):
  - 截取从指定位置开始到结束位置，包括开始位置，不包括结束位置
B: 注意事项
- 注意：返回值类型不再是StringBuffer本身，而是String类型

package com.heima.stringbuffer;

public class Demo5_StringBuffer {

    /**
     * @param args
     */
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("woaiheima");
        String str = sb.substring(4);//返回类型为String，原StringBuffer没有改变
        System.out.println(str);
        String str3 = sb.substring(4, 9);//包含头不包含尾
        System.out.println(str3);
    }

}

String和StringBuffer的相互转化

A:String -- StringBuffer
- a:通过构造方法
- b:通过append()方法
B:StringBuffer -- String
- a:通过构造方法
- b:通过toString()方法
- c:通过subString(0,length)

package com.heima.stringbuffer;

public class Demo6_StringBuffer {

    /**
     * @param args
     */
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("heima");
        
        String s1 = new String(sb);//通过构造将StringBuffer转换为String
        System.out.println(s1);
        
        String s2 = sb.toString();//通过toString方法将StringBuffer转换为String
        System.out.println(s2);
        
        String s3 = sb.substring(0,sb.length());//通过截取子字符串将StringBuffer转换为String
        System.out.println(s3);
    }

    private static void demo1() {
        StringBuffer sb1 = new StringBuffer("heima");//通过构造方法将字符串转换为StringBuffer对象
        System.out.println(sb1);
        
        StringBuffer sb2 = new StringBuffer("");//通过append方法将字符串转换为StringBuffer对象
        sb2.append("heima");
        System.out.println(sb2);
    }

}

例子

package com.heima.test;

public class Test1 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        int [] arr = {1,2,3};
        System.out.println(arrayToString(arr));
    }
    
    public static String arrayToString(int[] arr) {
        StringBuffer sb = new StringBuffer();//创建字符串缓冲区对象
        sb.append("[");//将[添加到缓冲区
        
        for (int i = 0; i < arr.length; i++) { //遍历数组
            //sb.append(arr[i] + ", ");//用这种方式会新建对象
            if(i == arr.length - 1) {
                sb.append(arr[i]).append("]"); //最后一个数字记得加]
            }else {
                sb.append(arr[i]).append(", ");
            }
        }
        return sb.toString();
    }

}

package com.heima.test;

import java.util.Scanner;

public class Test2 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);//创建键盘录入对象
        String line = sc.nextLine();//将键盘录入的字符串存储在line中
        /*
        StringBuffer sb = new StringBuffer(line);//将字符串转换为StringBuffer对象
        sb.reverse();//将缓冲区的内容反转
        System.out.println(sb.toString());
        */
        System.out.println(revString(line));
    }
    
    public static String revString(String line) {
        StringBuffer sb = new StringBuffer(line);//将字符串转换为StringBuffer对象
        sb.reverse();//将缓冲区的内容反转
        return sb.toString();
        
    }
}

StringBuffer和StringBuilder的区别

A:StringBuilder的概述
- 通过查看API了解一下StringBuilder类(很多方法与StringBuffer一样)
B:面试题
- String,StringBuffer,StringBuilder的区别
- StringBuffer和StringBuilder的区别
- StringBuffer是jdk1.0版本的，是线程安全的，效率低
- StringBuilder是jdk1.5版本的，是线程不安全的，效率高
- String和StringBuffer,StringBuilder的区别
- String是一个不可变的字符序列
- StringBuffer,StringBuilder是可变的字符序列

String和StringBuffer分别作为参数传递

A:形式参数问题
- String作为参数传递
- StringBuffer作为参数传递

package com.heima.stringbuffer;

public class Demo7_StringBuffer {

    /**
     * @param args
     */
    public static void main(String[] args) {
        String s = "heima";
        System.out.println(s);
        change(s);
        System.out.println(s);
        
        StringBuffer sb = new StringBuffer();
        sb.append("heima");
        System.out.println(sb);
        change(sb);
        System.out.println(sb);
    }

    public static void change(StringBuffer sb) {//传递的是地址值，引用的是同一个对象
        sb.append("itcast");
    }

    public static void change(String s) { //创造一个复制，赋值给s
        s += "itcast";
    }

}

冒泡排序和选择排序

冒泡排序.jpg

选择排序.jpg

package com.heima.array;

public class Demo1_Array {

    /**
     * @param args
     */
    public static void main(String[] args) {
        int[] arr = {24, 69, 80, 57, 13};
        bubbleSort(arr);
        //selectSort(arr);
        print(arr);
    }
    
    public static void bubbleSort(int[] arr) {
        for (int i = 0;i < arr.length - 1; i++) {  //只需要比较arr.length-1次
            for (int j = 0; j < arr.length - 1 - i; j++) { 
                if(arr[j] > arr[j+1]) {
                    swap(arr, j, j+1);
                }
                
            }
        }
    }
    
    public static void print(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
    
    public static void selectSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                if(arr[i] > arr[j]) {
                    swap(arr, i, j);
                }
            }
        }
    }
    
    private static void swap(int[] arr,int i,int j) {  //如果某个方法，只针对本类使用，不想让其他类使用就可以定义成私有的
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

二分查找

如果数组无序，就不能使用二分查找。因为如果你排序了，就会改变最原始的元素索引。

二分查找.jpg

package com.heima.array;

import javax.jws.soap.SOAPBinding;

public class Demo2_Array {

    /**
     * @param args
     */
    public static void main(String[] args) {
        int[] arr = {11,22,33,44,55,66,77};
        System.out.println(getIndex(arr, 22));
        System.out.println(getIndex(arr, 66));
        System.out.println(getIndex(arr, 88));
    }
    
    public static int getIndex(int[] arr, int value) {
        int min = 0;
        int max = arr.length - 1;
        int mid = (min + max) / 2;
        
        while(arr[mid] != value) {  //当中间值不等于要找的值，就开始循环查找
            if(arr[mid] < value) {
                min = mid + 1;
            }else if(arr[mid] > value) {
                max = mid -1;
            }
            
            mid = (min + max) / 2;
            
            if(min > max) {
                return -1;
            }
        }
        return mid;
    }

}

Arrays类的概述和方法使用(视频中包括源码分析）

A:Arrays类概述
- 针对数组进行操作的工具类。
- 提供了排序，查找等功能。
B:成员方法
- public static String toString(int[] a)
- public static void sort(int[] a)
- public static int binarySearch(int[] a, int key)

package com.heima.array;

import javax.jws.soap.SOAPBinding;

public class Demo2_Array {

    /**
     * @param args
     */
    public static void main(String[] args) {
        int[] arr = {11,22,33,44,55,66,77};
        System.out.println(getIndex(arr, 22));
        System.out.println(getIndex(arr, 66));
        System.out.println(getIndex(arr, 88));
    }
    
    public static int getIndex(int[] arr, int value) {
        int min = 0;
        int max = arr.length - 1;
        int mid = (min + max) / 2;
        
        while(arr[mid] != value) {  //当中间值不等于要找的值，就开始循环查找
            if(arr[mid] < value) {
                min = mid + 1;
            }else if(arr[mid] > value) {
                max = mid -1;
            }
            
            mid = (min + max) / 2;
            
            if(min > max) {
                return -1;
            }
        }
        return mid;
    }

}

基本数据类型包装类的概述

A:为什么会有基本数据类型包装类
- 将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。
B:常用操作
- 常用的操作之一：用于基本数据类型与字符串之间的转换
C:基本数据类型和包装类的对应
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean

package com.heima.wrapclass;

public class Demo1_Integer {

    public static void main(String[] args) {
        System.out.println(Integer.toBinaryString(60));
        System.out.println(Integer.toOctalString(60));
        System.out.println(Integer.toHexString(60));
    }

}

Integer类的概述和构造方法

A:Integer类概述
- 通过API，查看Integer类的说明
  *Integer类在对象中包装了一个基本类型int的值
  *该类提供了多个方法，能在int类型和String类型之间互相转换
  *还提供了处理int类型时非常有用的其他一些常量和方法
B:构造方法
- public Integer(int value)
- public Integer(String s)
C:案例演示
- 使用构造方法创建对象

package com.heima.wrapclass;

public class Demo2_Integer {

    public static void main(String[] args) {
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
        
        Integer i1 = new Integer(100);
        System.out.println(i1);
        
        //Integer i2 = new Integer("abc"); //java.lang.NumberFormatException数字格式异常，因为abc不是数字字符串，所以转换会报错。
        Integer i2 = new Integer("123");
        System.out.println(i2);
    }

}

String和int类型的相互转换

A:int -- String
- a:和""进行拼接
- b:public static String valueOf(int i)
- c:int -- Integer -- String(Integer类的toString方法（）)
- d:public static String toString(int i)（Integer类的静态方法）
B:String -- int
- a:String -- Integer -- int
  - public static int parseInt(String s)

package com.heima.wrapclass;

public class Demo3_Integer {

    /**
     * @param args
     */
    public static void main(String[] args) {
        /*基本数据类型包装类有八种，其中七种都有parseXxx的方法
        //可以将这七种的字符串表现形式转换成基本数据类型
         * char的包装类Character中没有pareseXxx的方法
         * 字符串到字符的转换通过tocharArray()就可以把字符串转换为字符数组
        */
        String s1 = "true";
        boolean b = Boolean.parseBoolean(s1);
        System.out.println(b);
    }

    private static void demo1() {
        //int -------> String int转换成String
        int i = 100;
        String s1 = i + "";   //推荐用，比较简单
        String s2 = String.valueOf(i); //推荐用，不用创建多个类
        
        Integer i2 = new Integer(i);
        String s3 = i2.toString();
        
        String s4 = Integer.toString(i);
        System.out.println(s4);
        
        //string -------> int String转换成int
        String s = "200";
        Integer i3 = new Integer(s);
        int i4 = i3.intValue();    //将Integer转换成了int数
        
        int i5 = Integer.parseInt(s); //将String转换为int，推荐用这种
        System.out.println(i4);
        System.out.println(i5);
    }

}

JDK5的新特性

A:JDK5的新特性
- 自动装箱：把基本数据转换为包装类类型
- 自动拆箱：把包装类类型转换为基本类型
B:案例演示
- JDK5的新特性自动装箱和拆箱
- Integer ii = 100;
- ii += 200;
C:注意事项
- 在使用时，Integer x = null;代码就会出现NullPointerException
- 建议先判断是否为null，然后再使用

package com.heima.wrapclass;

public class Demo4_JDK5 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        int x = 100;
        Integer i1 = new Integer(x);    //将基本数据类型包装成对象，手动装箱
        int y = i1.intValue();          //将对象转换为基本数据类型，手动拆箱
        
        Integer i2 = 100;               //自动装箱，把基本数据类型转换成对象
        int z = i2;                     //自动拆箱，把对象转换为基本数据类型
        System.out.println(z);
        
        Integer i3 = null;            //底层用i3调用intValue，但是i3是null，
        int a = i3 + 100;             //null调用方法就会出现空指针异常
        System.out.println(a);        //java.lang.NullPointerException
    }

}

面试题，此处有源码解析

package com.heima.wrapclass;

public class Demo5_Integer {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Integer i1 = new Integer(97);
        Integer i2 = new Integer(97);
        System.out.println(i1 == i2);        //false
        System.out.println(i1.equals(i2));   //true
        
        Integer i3 = new Integer(197);
        Integer i4 = new Integer(197);
        System.out.println(i3 == i4);           //false
        System.out.println(i3.equals(i4));      //true
        System.out.println("-------------");
        Integer i5 = 127;
        Integer i6 = 127;
        System.out.println(i5 == i6);           //true
        System.out.println(i5.equals(i6));      //true
        
        Integer i7 = 128;
        Integer i8 = 128;
        System.out.println(i7 == i8);           //false
        System.out.println(i7.equals(i8));      //true
        /*
         * -128到127是byte的取值范围，如果在这个取值范围内，自动装箱就不会新创建对象，
         * 而是从常量池中获取。如果超过了byte取值范围就会再新创建对象
         */
    }

}