java基础--eclipse使用、object类、String类、stringbuffer类

eclipse使用的步骤

第一步： 选择工作目录。 以后在Eclipse上面写的所有代码都是在工作目录上的。

第二步： 在Project Exploer 窗口上创建一个工程，以后我们写代码都是以工程作为单位的。
新建工程的 步骤：
    Project Exploer 窗口右击----------> New---------> java Project

第三步： 在工程的src目录下右击，new 一个Class就创建了一个类。

    工程的目录介绍：
        settings： elcipse自动生成的配置文件。 别碰它。
        bin: 用于存放所有的class文件。
        src: 用于存放所有的java源文件。

第四步： 运行java文件。

    方式一：  java的源代码右击-------->run  as -----------> java application

    方式二：  绿色箭头--------->run  as -----------> java application

    方式三：  快捷键的运行： ctrl+ f11

使用eclipse 好处

1. ctrl + / 内部补全，只能提示。
   1. 不需要你再使用javac工具编译，你在Eclipse上面一旦保存，Eclipse自动编译。
   2. 精准报错，自动修复(ctrl+ 1)。

window—-》Reset Perspective 重置界面的窗口

Object类

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

Object类型的多态引用是会付出代价的

当你把对象装进ArrayList<Dog>时，它会被当做Dog来输入输出

ArrayList<Dog> myDogArraylist = new ArrayList<Dog>();
Dog dog1 = new Dog();
myDogArraylist.add(dog1);
Dog d = myDogArraylist.get(0);

但若你把它声明为ArrayList<Object>时会怎样？

ArrayList<Object> myDogArraylist = new ArrayList<Object>();
Dog dog1 = new Dog();
myDogArraylist.add(dog1);
// 下面的代码无法通过编译。get（）方法会返回Object类型，编译期无法确认它是Dog
Dog d = myDogArraylist.get(0);

任何从ArrayList<Object>取出的东西都会被当做Object类型的引用而不管它原来是什么！

Object类常用的方法：

toString();     返回该对象的字符串表示。 返回一个字符串用于描述该对象的。

疑问： toString() 有何作用？

  重写toString之后，我们直接输出一个对象的时候，就会输出符合我们所需求的格式数据。

equals(Object obj)   用于比较两个对象的内存地址，判断两个对象是否为同一个对象。

hashCode()   返回该对象的哈希码值(大家可以把哈希码就 理解成是对象的内存地址)/

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

查看源代码的方式：

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

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

class Person{

int id;

String name;

public Person(int id, String name) {
    this.id = id;
    this.name = name;
}

public Person() {
}

//目前我需要直接输出一个对象的时候，输出 的格式是： 编号：110 姓名： 狗娃  这种格式。 目前Object的
//  toString方法无法满足子类的需求，那么这时候我们就应该对Object类的toString进行重写。
@Override
public String toString() {
    return "编号："+ this.id + " 姓名："+this.name;
}

//为什么要重写：Object的equals方法默认比较的是两个对象的内存地址，我目前需要比较的是两个对象的身份证，所以Object类的equals方法不符合我现在的需求。
@Override
public boolean equals(Object obj) {
    Person p  = (Person)obj;
    return this.id== p.id;
}

@Override
public int hashCode() {
    return  this.id;
}
}
public class Demo1 {

public static void main(String[] args) {

    /*
    Object o = new Object();
    System.out.println(o.toString());  // java.lang.Object@18b3364    返回的字符串表示： 完整类名+@+ 对象的哈希码
    System.out.println(o);  // 通过查看源代码得知，直接输出一个对象 的时候，实际上在println方法内部会调用这个 调用的toString方法，把把toString方法返回的内容输出。
    //疑问： 为什么直接输出一个对象的时候和输出对象的toString方法返回的字符串结果是一样的呢？

    Person  p1 = new Person(110,"狗娃");
    System.out.println("p1:"+p1);
    //如果我们能够输出一个p对象的时候，输出的格式： 编号：110 姓名： 狗娃..
    Person  p2 = new Person(112,"狗剩");
    System.out.println("p2:"+p2);
    */

    Person p1 = new Person(110,"狗娃");
    Person p2 = new Person(110,"陈富贵");
    //需求：在现实生活中只要两个人的身份证一致，那么就是同一个人。
    System.out.println("p1与p2是同一个对象吗？"+ p1.equals(p2));

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

String类

笔试题目：new String(“abc”)创建了几个对象？

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

String str1 = "hello";
String str2 = "hello";
String str3 = new String("hello");
String str4 = new String("hello");
System.out.println("str1==str2?"+(str1==str2));  // true
System.out.println("str2==str3?"+(str2==str3));  //false
System.out.println("str3==str4?"+(str3==str4));  // false
System.out.println("str3.equals(str2)?"+(str3.equals(str4))); //true
//是String类重写了Object的equals方法，比较的是两个字符串对象 的内容 是否一致。
// "=="用于比较 引用数据类型数据的时候比较的是两个对象 的内存地址，equals方法默认情况下比较也是两个对象 的内存地址。

String构造方法

String() 创建一个空内容 的字符串对象。

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

String(byte[] bytes, int offset, int length)
    bytes :  要解码的数组
    offset： 指定从数组中那个索引值开始解码。
    length：　要解码多个元素。

String(char[] value)  使用一个字符数组构建一个字符串。
String(char[] value, int offset, int count)  使用一个字符数组构建一个字符串， 指定开始的索引值，与使用字符个数。
String(int[] codePoints,int offset,int count)
String(String original)

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

String str = new String();
    byte[] buf = {97,98,99};

    str = new String(buf); //使用一个字节数组构建一个字符串对象
    str = new String(buf,1,2);   //使用一个字节数组构建一个字符串对象,指定开始解码 的索引值和解码的个数。
    System.out.println("字符串的内容："+str);//结果：字符串的内容：bc
    char[] arr = {'明','天','是','圣','诞'};
    str = new String(arr); //使用字符数组构建一个字符串
    str = new String(arr,3,2);
    System.out.println("字符串的内容："+str);//字符串的内容：圣诞
    int[]   buf2 = {65,66,67};
    str = new String(buf2,0,3);
    System.out.println("字符串的内容："+str);//字符串的内容：ABC
    str = new String("abc");
    System.out.println("字符串的内容："+str);//字符串的内容：abc

使用常量.equals可以避免出现空指针异常的情况，建议这样使用

"中国".equals(str)

2.2 获取方法

int length()  获取字符串的长度
char charAt(int index) 获取特定位置的字符 (角标越界)
int indexOf(String str) 查找子串第一次出现的索引值,如果子串没有出现 在字符串中，那么则返回-1表示。
int lastIndexOf(String str) 查找子串最后一次出现的索引值 , 如果子串没有出现 在字符串中，那么则返回-1表示

2.3 判断方法

boolean endsWith(String str) 是否以指定字符结束
boolean isEmpty()是否长度为0 如：“”，如果是null会报错。
boolean contains(CharSequences) 是否包含指定序列 应用：搜索
boolean equals(Object anObject) 是否相等
boolean equalsIgnoreCase(String anotherString) 忽略大小写是否相等

2.4 转换方法

char[] toCharArray()  将字符串转换为字符数组
byte[]  getBytes();

字节数组与字符数组、字符串他们三者之间是可以互相转换。

其他方法

String replace(String oldChar, String newChar) 替换
String[] split(String regex) 切割

String substring(int beginIndex)   指定开始 的索引值截取子串
String substring(int beginIndex, int endIndex)指定开始 与结束的索引值截取子串，包头不包尾  注意：截取的内容是包括开始的索引值，不包括结束的索引值

String toUpperCase() 转大写
String toLowerCase() 转小写
String trim() 去除字符串首尾的空格

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

//字符串反转
public static String reverse(String str){
    char[] arr = str.toCharArray();
    for(int startIndex = 0 , endIndex=arr.length-1 ; startIndex<endIndex; startIndex++,endIndex--){
            char temp = arr[startIndex];
            arr[startIndex] = arr[endIndex];
            arr[endIndex] = temp;
    }
    //使用字符数组构建一个字符串。
    return new String(arr);
}

//  需求1：自己实现trim的方法。
public static String myTrim(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);
}

stringbuffer类

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

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

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

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

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

使用Stringbuffer无 参的构造函数创建 一个对象时，默认的初始容量是多少？ 如果长度不够使用了，自动增长多少倍？

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