Java学习笔记（12）

eclipse使用的步骤：

1.选择工作目录。以后在Eclipse上面写的所有代码都是在工作目录上的

2.在Project Exploer窗口上新建一个工程，以后我们写代码都是以工程为单位的

3.在工程的src目录下右击，new一个class或者一个package

　　工程的目录介绍：

1. settings：eclipse自动生成的配置文件，别碰它
2. bin：用于存放所有的class文件
3. src：用于存放所有的java源文件
4. 运行java文件
5. 导入工程

运行有三种方式：

1. java的源代码右击——————>run as————————>java application
2. 绿色箭头的右边向下箭头——————>run as————————>java application
3. Ctrl+F11

使用eclipse的好处：

1. ctrl+/   内容补全
2. 不需要你在使用javac工具编译，你在eclipse上面一旦保存，Eclipse自动编译
3. 精准报错，自动修复（ctrl+1）

Object类是所有类的终极父类。任何一个类都继承了Object类

Object类：

常用的方法：

1. toString()方法      返回该对象的字符串表示    返回的字符串表示：完整类名+@+对象的哈希码
2. equals（Object obj）方法    用于比较两个对象的内存地址，判断两个对象是否为同一个对象
3. hashcode（）方法      返回该对象的哈希码值

疑问：toString（）方法有什么作用？

查看源代码的方式：

　　　　方式一：按住ctrl键单击你需要看的源代码

　　　　方式二：把光标移动到你需要查看的代码处按下F3

这时候，我们就有了疑问，为什么要查看源代码呢？

1. 查看源代码可以了解别人是如何写出这个技术的，让我们了解的更加的深入
2. 吸收大牛的思想

看源代码最忌讳的一点：不要每行代码都弄懂是什么意思，能看个大概猜出他意思就足以

例题：改写toString方法

public class Demo1 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Demo1 d=new Demo1();
        System.out.println("hashcode="+d.hashCode());
        Object o=new Object();
        System.out.println("toString:"+o.toString());  //toString:java.lang.Object@2c13da15
        System.out.println(o);
        Person p1=new Person(110,"狗娃");
        System.out.println(p1);
        Person p2=new Person(120,"狗蛋");
        System.out.println(p2);
    }

}
class Person{
    int id;
    String name;
    public Person() {}
    public Person(int id,String name) {
        this.id=id;
        this.name=name;
    }
    public String toString() {
        return "编号："+this.id+"姓名："+this.name;
    }
}

结果：
hashcode=1361960727
toString:java.lang.Object@2c13da15
java.lang.Object@2c13da15
编号：110姓名：狗娃
编号：120姓名：狗蛋

经过这次例题，我们可以看出，重写toString之后，我们直接输出一个对象的时候，就会输出符合我们需求的格式数据

重写equals（）方法

@Override
    public boolean equals(Object obj) {
    // TODO Auto-generated method stub
        Person p=(Person)obj;
         return this.id==p.id;
    }

结果：
p1与p2是同一个对象吗？true

java种的规范：一般我们重写了一个类的equals方法我们都会重写它的hashcode方法。

@Override
    public int hashCode() {
        // TODO Auto-generated method stub
        return this.id;
    }

System.out.println("p1哈希码:"+p1.hashCode());
        System.out.println("p2哈希码:"+p2.hashCode());

结果：
p1哈希码:110
p2哈希码:110

这是因为比如equals方法返回为true，但是hashcode返回的值不一样，这就让人看起来很难受。

String   字符串类：

笔试题目：new String（"abc"）创建了几个对象

两个对象，一个对象是位于字符串常量中，一个对象是位于堆内存中。

使用equals方法的时候，我们一般都会将常量作为方法的调用者，这样避免空指针异常

test(null);

public static void test(String str) {
        if ("中国".equals(str)) {
            System.out.println("回答正确");
        }
        else {
            System.out.println("回答错误");
        }
    }

结果：
回答错误

String类的构造方法：

String（）　　创建一个空内容的字符串对象。

String str=new String();

String（byte[] bytes）    使用一个字节数组构建一个字符串对象

public static void main(String[] args) {
        // TODO Auto-generated method stub
        String str=new String();
        byte[] buf= {97,98,99};
        str=new String(buf);
        System.out.println("字符串的内容是："+str);
    }

结果：
字符串的内容是：abc

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

bytes:要解码的数组

offset：指定从数组中哪个索引值开始解码。

length：要解码多少个字符

str=new String(buf,1,2);
        System.out.println("字符串的内容是："+str);

结果：
字符串的内容是：bc

String(char[] value)     使用一个字符数组构建一个字符串

String(char[] value, int offset, int count) 使用一个字符数组构建一个字符串，然后从给的的索引值开始，解码length个字符

char[] arr= {'明','天','会','更','好'};
        str=new String(arr);
        System.out.println("字符串的内容是："+str);

结果：
字符串的内容是：明天会更好

String(int[] codePoints, int offset, int count)  int类型的索引

String(String original)    初始化一个新创建的String对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本

记住：使用字节数组或者字符数组都可以构建一个字符串对象。

获取方法：

int length   获取字符串的长度

char  charAt（int index）获取特定位置的字符（角标越界）

int indexOf（String str）查找字串第一次出现的索引值，如果字串没有出现在字符串中，那么则返回-1表示。

int lastIndexOf(String str)    获取最后一个字符的位置，如果字串没有出现在字符串中，那么则返回-1表示。

public static void main(String[] args) {
        // TODO Auto-generated method stub
        String str="abc中国ab中国";
        System.out.println("字符串的字符个数："+str.length());
        System.out.println("根据索引值获取对应的字符："+str.charAt(3));
        System.out.println("查找字串第一次出现的索引值："+str.indexOf("中国"));
        System.out.println("查找字串第一次出现的索引值："+str.lastIndexOf("中国"));
    }

结果：
字符串的字符个数：9
根据索引值获取对应的字符：中
查找字串第一次出现的索引值：3
查找字串第一次出现的索引值：7

判断方法：

boolean endsWith（String str）   是否以指定字符串结束

boolean  isEmpty（）   是否长度为0

boolean  contains（CharSequences）  是否包含指定序列  应用：搜索

boolean   equals（Object  anObject）  是否相等

boolean   equalsIgnoreCase（String anotherString）忽略大小写是否相等

public static void main(String[] args) {
        // TODO Auto-generated method stub
        String str="Demo.java";
        System.out.println("是否以指定的字符串结束:"+str.endsWith("java"));
        System.out.println("判断字符串是否为空内容："+str.isEmpty());
        System.out.println("判断字符串是否包含指定的内容"+str.contains("De"));
        System.out.println("判断两个字符串的内容是否一致："+"DEMO.JAVA".equals(str));  //区分大小写
        System.out.println("判断两个字符串的内容是否一致（忽略大小写比较）"+"demo.java".equalsIgnoreCase(str));
    }

结果：
是否以指定的字符串结束:true
判断字符串是否为空内容：false
判断字符串是否包含指定的内容true
判断两个字符串的内容是否一致：false
判断两个字符串的内容是否一致（忽略大小写比较）true

转换方法：

String （char【】 value）  将字符数组转换为字符串

String  （char【】value，int offset，int count）

static  String  valueOf（char[] data）

static String valueOf（char[] data,int offst,int count）

char[]  toCharArray() 将字符串转化为字符数组

byte[]   getBytes（）

字节数组，字符数组，字符串它们三者之间是可以互相转换的。

char[] buf=str.toCharArray();  //转换为字符数组
        System.out.println("字符数组："+Arrays.toString(buf));
        byte[] buf2=str.getBytes();
        System.out.println("字节数组："+Arrays.toString(buf2));

结果:
字符数组：[D, e, m, o, ., j, a, v, a]
字节数组：[68, 101, 109, 111, 46, 106, 97, 118, 97]

String replace(char oldChar,char newChar)   替换   也可以传两个字符串

String【】split（String regex）切割

String substring（int beginIndex） 截取字串

String substring（int beginIndex，int endIndex） 截取字符串

String toUpperCase（） 转大写

String toLowerCase（）转小写

String trim（） 去除字符串首尾的空格　　

import java.util.*;
public class Demo6 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String str="今天晚上不考试";
        System.out.println("指定新内容替换旧的内容："+str.replace("不", "要"));
        System.out.println("指定新内容替换旧的内容："+str.replace("不", "要好好"));
        str="大家-下-午-好";
        String[] arr=str.split("-");
        System.out.println("字符串数组："+Arrays.toString(arr));
        str="广州传智播客";
        System.out.println("指定开始的索引值截取子串："+str.substring(2));
        System.out.println("指定开始和结束的索引值截取子串："+str.substring(2,4));//包头不包尾 注意：截取的内容是包括开始的索引值，不包括结束的索引值，截取的位置是结束的位置-1位
        str="abcde中国";
        System.out.println("转大写："+str.toUpperCase());
        str="ASsdadaHGKda";
        System.out.println("转小写："+str.toLowerCase());
        str="            大家最近       都非常  努力            ";
        System.out.println("去除字符串首尾的空格："+str.trim());
    }

}

结果：

指定新内容替换旧的内容：今天晚上要考试
指定新内容替换旧的内容：今天晚上要好好考试
字符串数组：[大家, 下, 午, 好]
指定开始的索引值截取子串：传智播客
指定开始和结束的索引值截取子串：传智
转大写：ABCDE中国
转小写：assdadahgkda
去除字符串首尾的空格：大家最近       都非常  努力

例1：自己重写Tirm方法

public class Demo7 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String str="            传智         播客          ";
        System.out.println("字符串："+str);
        System.out.println("去除空格后的字串："+myTirm(str));
    }
    public static String myTirm(String str) {
        //先转换字符数组
        char[] arr=str.toCharArray();
        //定义两个变量记录开始的索引值与结束的索引值
        int startIndex=0;
        int endIndex=arr.length-1;
        //确定开始的索引值
        while (true) {
            if (arr[startIndex]==' ') {
                startIndex++;
            }
            else {
                break;
            }
        }
        //确定结束的索引值
        while (true) {
            if (arr[endIndex]==' ') {
                endIndex--;
            }
            else {
                break;
            }
        }
        //截取子串返回
        return str.substring(startIndex, endIndex+1);
    }
}

结果;
字符串：            传智         播客
去除空格后的字串：传智         播客

例2：从一串文件名中获取文件名称

public static void getFileName(String path) {
        int index=path.lastIndexOf("\\");
        String fileName=path.substring(index+1);
        System.out.println("文件名："+fileName);
    }

str="D:\\20120512\\day12\\Demo1.java";
        getFileName(str);

结果：
文件名：Demo1.java

例3：将字符串对象中存储的字符反序

public static String reverse(String str) {
        char[] arr=str.toCharArray();
        char[] arr2=new char[arr.length];
        int index=0;
        for (int i=arr.length-1;i>=0;i--) {
            arr2[index++]=arr[i];
        }
        String str2=new String(arr2);
        return str2;
    }

str="新中国好";
        System.out.println("倒置后的字符串："+reverse(str));

结果：
倒置后的字符串：好国中新

例4：统计子串出现的个数

public static void getCount(String str,String target) {
        int count=0;  //用于记录出现的次数
        int fromIndex=0;  //记录从哪个索引值开始寻找目标字串
        while (str.indexOf(target, fromIndex)!=-1) {
            //如果indexOf返回的不是-1，那么意味着找到了目标元素
            fromIndex=str.indexOf(target, fromIndex);
            count++;
            fromIndex=fromIndex+target.length();
        }
        System.out.println("出现的次数："+count);
    }

str="abcjavaabcjavajavaphpjava";
        getCount(str,"java");

结果：
出现的次数：4

字符串特点：字符串是常量，他们的值在创建之后不能更改

字符串的内容一旦发生变化，那么马上会创建一个新的对象

注意：字符串的内容不适宜频繁修改，因为一旦修改马上就会创建一个新的对象。

如果需要频繁修改字符串的内容，建议使用字符串缓冲类（StringBuffer）。

StringBuffer  其实就是一个存储字符的容器。

添加数据：append（）；

StringBuffer底层是依赖了一个字符数组才能存储字符数据的，该字符串数组默认的初始容量是16，如果字符数组的长度不够使用时，自动增长一倍

容器应该具备的行为:  增删查改判断