丨你微笑时好美丶

博客园 首页 联系 订阅 管理

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,如果字符数组的长度不够使用时,自动增长一倍

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

posted on 2019-02-04 23:25  丨你微笑时好美丶  阅读(287)  评论(0编辑  收藏  举报