黑马程序员技术交流社区

标题: java基础笔记 [打印本页]

作者: MengDeKaiShi 时间: 2015-1-2 22:27
标题: java基础笔记
Object类
所有类都直接或简介继承自Object类
Equals（）方法
基本数据类型用==作比较，其实比较的是值的大小
引用数据类型用==作比较，其实比较的是该引用的地址值
新建的类需要比较两个对象是否相等时，一般会重写父类（object）继承的equals方法，因为父类中的equals方法与==一模一样，而==用来比较引用类型的话，比较的是引用类型的地址值

String的equals方法：字符串底层其实是一个字符数组char[]，String已经重写了Object的equals方法，首先比较是否是同一个对象，如果不是同一个对象，会将字符串转成字符数组，判断两个String对象的长度是否相等，每个字符是否相等，只要相等，equals方法就会返回true
getClass（）方法
对于类来说，都只有一个.class文件，当类加载时，.class文件会被封装进Class类中，Class类中存在很多属性和方法，包含了.class中所有的东西，对于类来说，只有一个.class文件，只加载一次，所有也就只有一个对应的Class
getClass(  )方法用于获取当前对象运行时类的 Class 对象。

/****示例***/
Person p1=new Person("zhang",22);//实例化两个Person类对象p1,p2
Person p2=new Person("zhang",18);
Class c1= p1.getClass();//获取p1的Class对象
Class c2=p2.getClass();//获取p2的Class对象
System.out.println(c1.getName());//答应Class对象的名字
System.out.println(c1==c2);//引用对象的==比较的是地址值
//p1和p2都是Person类的实例，
//所以他们的Class对象应指向同一块内存空间，返回true
hashCode（）方法
返回该对象的哈希码值，若子类未重写此方法，将返回一个本地的值（无法预知此值，由底层方法计算）
若子类重写equals方法，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具有相等的哈希码。
toString（）方法
Object 类的 toString 方法返回一个字符串，该字符串由类名（对象是该类的一个实例）、at 标记符“@”和此对象哈希码的无符号十六进制表示组成。换句话说，该方法返回一个字符串，它的值等于：
getClass().getName() + '@' + Integer.toHexString(hashCode())

直接输出一个对象，其实就是在输出toString（）方法返回的字符串

建议所有的子类重写此方法以返回一个清晰明了的信息
代码示例
/**
* 定义一个Person类
*/
package org.model;
public class Person {
String name;//姓名
int age;//年龄

public Person() {

}

public Person(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;
}

/*
   * 重写Object的equals方法
   *若2个对象的年龄和姓名都相同，则返回true
   *instanceof用于判断前面是否是后面的对象
   */
@Override
public boolean equals(Object obj) {
if(this==obj) return true;
if (obj instanceof Person) {
Person p = (Person) obj;
return (p.getName() == this.name) && (p.getAge() == this.age);
}
return false;
}

/*
   * 重写Object的toString()方法
   * 返回一个对象的姓名和年龄的字符串
   */
@Override
public String toString() {
return "name:"+name+"  age:"+age;
}

/*
   *重写Object的hashCode()方法
   *若未重写此方法，将返回一个本地的值（无法知道此值，由底层方法计算）
   *若重写了equals方法，通常建议重写此方法
   *因为hashCode 的常规协定是：
   *如果根据 equals(Object) 方法，两个对象是相等的，
*那么对这两个对象中的每个对象调用 hashCode 方法都必须生成相同的整数
*结果。
   *两个对象不相等，那么对这两个对象中的任一对象上调用 hashCode 方法时，
   *要求一定生成不同的整数结果。
   */
@Override
public int hashCode() {

return age;
}
}

/**
* 这是一个测试类
*/
package org.object;
import org.model.Person;

public class ObjectDemo {

/**
   * @param args
   */
public static void main(String[] args) {
Person p1=new Person("zhang",22);
Person p2=new Person("zhang",22);
//重写了equals方法，如果姓名年龄相同，则认为2个对象相等
System.out.println(p2.equals(p1));
//==判断的是2个对象的地址值是否相等，只要不是同一个对象，这里就会返回false
System.out.println(p1==p2);

//getClass（）方法返回的是当前对象所属的类的字节码对象
Class c1= p1.getClass();
Class c2=p2.getClass();
System.out.println(c1.getName());//获取类名
//c1 c2都是Person类的对象，所以他们有同一个Class对象，返回true
System.out.println(c1==c2);

//输出toString方法返回的字符串内容，重写了toString方法，所以应该输出姓名年龄
System.out.println(p1.toString());
System.out.println(p1);//打印一个对象，默认就是调用对象的
toString方法

//重写了hashCode（）方法，将返回对象的年龄值作为该对象的哈希值
System.out.println(p2.hashCode());//输出p2的哈希值
}

}

String类
多个字符组成的一串数据。
字符串是常量，他们的值在创建之后就不能更改（所以可以共享常量池的字符串常量）
字符串缓冲区支持可变的字符串
优点：高效、操作方法多、使用方便
缺点：会产生很多临时的变量，浪费内存空间
构造方法
String s = new String();
String s = new String(byte[] bys);
String s = new String(byte[] bys,int index,int length);
参数：
bys - 要解码为字符的 byte
index - 要解码的第一个 byte 的索引
length - 要解码的 byte 数
String s = new String(char[] chs);
String s = new String(char[] chs,int index,int length);
参数：
chs - 作为字符源的数组。
index - 初始偏移量。
length - 长度。
String s = new String(String str);
String s = "hello";(一般就用这种方式)
成员方法
判断
boolean equals(Object obj)：将此字符串与指定的对象比较
boolean equalsIgnoreCase(String str)：忽略大小写，将此字符串与指定的对象比较
boolean contains(CharSequence s)：判断此字符串是否包含指定的 char 值序列
boolean startsWith(String str)：判断此字符串是否以指定的字符串开始
boolean endsWith(String str)：判断此字符串是否以指定的字符串结尾
boolean isEmpty()：判断字符串是否是空串（长度为0）
获取
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)：获取从指定索引值开始字符串第一次出现的索引值
String substring(int start)：从指定索引值开始截取字符串
String substring(int start,int end)：截取start到end之间的字符串（含左不含右）
代码示例
public class StringDemo3 {

public static void main(String[] args) {
String s="abcdefghijklmnopqrstuvwxyzd";

int length=s.length();//获取长度
System.out.println(length);

//索引值均从0开始
char c=s.charAt(10);//获取指定索引值的字符
System.out.println(c);

int index=s.indexOf('d');//获取指定字符在字符串中第一次出现的索引值
System.out.println(index);

index=s.indexOf('d', 10);
System.out.println(index);

index=s.indexOf("jkl");//获取指定字符串在字符串中第一次出现的索引值
System.out.println(index);

//注意事项,不管是因为何种原因找不到，只返回-1，不会报错
//如果找到了，就返回对应字符或者字符串的索引值
index=s.indexOf("abc",10000);
System.out.println(index);
index=s.indexOf("hello");
System.out.println(index);

//substring方法并不会对原串进行操作，而是返回一个新值
String s1=s.substring(6);
System.out.println(s);
System.out.println(s1);

s1=s.substring(6, 10);//截取字符串的时候，含头不含尾
System.out.println(s1);

//截取最后一个字符
s1=s.substring(s.length()-1);
System.out.println(s1);

//end的值不能超过s.length(),
//否则会产生异常StringIndexOutOfBoundsException
s1=s.substring(s.length()-1,s.length()+1);
System.out.println(s1);
}
}

转换
byte[] getBytes()：获取字节数组
char[] toCharArray()：获取字符数组
static String copyValueOf(char[] chs)：将字符数组转换为字符串（同new String(char[] chs) ）
static String valueOf(char[] chs):将字符数组转成字符串
static String valueOf(int i)：将int型转为字符串
String toLowerCase()：全部转成小写
String toUpperCase()：全部转成大写
String concat(String str)：拼接字符串

作者: 466273082 时间: 2015-1-2 22:36
好复杂呀,我要努力学习呀

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2