Object类 存储与java.lang包中,java中所有的类,都直接或者间接继承Object类,此类有构造方法,不过它的第一行不是super.Object类中定义了11个方法,主要有: toString() 返回对象的字符串表现形式
equals() 对象之间的比较
native为修饰符,为本地方法,运行在本地方法栈中,凡是见到native修饰的方法,方法的源代码非java代码编写,实际源代码为C++,在本地注册,运行程序时需要操作系统支持,凡是native修饰的方法,都看不到方法的源代码.
import java.util.Scanner;
/*
* Object类方法toString() 返回的是该对象的字符串表示
* toString()运行结果返回一个字符串
*
* 只有在输出语句中，默认调用对象的toString方法
*
* public String toString(){
* return getClass().getName()+"@"+Integer.toHexString( hashCode() )
* }
* getClass() 获取运行时期类class文件的对象
* getName() 通过获取到的class文件对象，获取全类名
*
* hashCode() : public native int hashCode()
* 运行结果是int类型，是一个十进制的数据，数据地址值
*
* Integer.toHexString()将十进制转十六进制
*
* 但是，输出语句中，打印了toString的结果是一个地址
* new 出来的对象都是不同地址 因此需要重写toString()方法
*
*
*/
public class ObjectDemo1 {
public static void main(String[] args) {
// 创建Person对象，调用对象中的toString方法
Person p = new Person("李四", 23);
System.out.println(p.toString());
System.out.println(p);
/*
* Scanner sc = new Scanner(System.in);
* System.out.println(sc.toString());
*/
}
}
Object类的equals()方法
/*
* Object类的方法 equals(Object obj)
* 指示其他某个对象是否与此对象“相等”。
*
* 其他某个对象 方法参数为obj
* 此对象为this
* equals方法的源代码为:
*
* public boolean equals(Object obj){
* return this == obj;
* }
* this和obj都是对象引用， == 比较的对象内存地址
*
* 对象之间比较地址，没有意义
* 需要重写equals方法，建立对象自己的比较方式
*/
public class ObjectDemo2 {
public static void main(String[] args) {
// 创建两个Person对象
Person p1 = new Person("李四", 25);
Person p2 = new Person("张三", 25);
String s = "hgj";
String s1 = "Hgj";
boolean a = s.equals(s1);
System.out.println(a);
// p1对象调用自己的equals方法和p2进行比较
boolean b = p1.equals(p1);
System.out.println(b);
}
}
这里有一个equals和==区别的面试题
equals方法 默认比较对象内存地址是否相同
重写equals建立对象自己的比较方式，比较对象的成员变量值
== 比较运算符 1)比较基本类型，比较具体数值是否相同
2)比较引用类型，比较内存地址是否相同
Scanner类 可以接受键盘录入,使用Scanner类时需要导入util包,是JDK1.5加入的新特性,Scanner类的构造器,使用的格式是:Scanner(InputStream in) System.in
使用的成员方法是: int nextInt() 接收录入的整型数据
String nextLine()接收字符串 ，扫描输入的一行
String类 String类源代码， private final char value[]
/*
* String类构造方法
* 存在很多重载形式
*
* 下面对每个构造方法，单独定义一个方法进行演示
* 使用main方法来调用
*/
public class StringDemo1 {
public static void main(String[] args) {
method_5();
}
/*
* String 构造方法，带有1个参数
* 传递就String类型
*/
public static void method_5(){
//创建String对象，传递字符串
String s = new String("abc");
System.out.println(s);
}
/*
* String 构造方法，带有3个参数
* 字符数组，int，int
* 第一个int，开始下标，第二个int，获取几个
* 将字符数组的一部分转成字符串
*/
public static void method_4(){
//定义字符数组
char[] ch = {'a','b','c','d'};
//创建String对象，传递字符数组,从0开始，获取2个
String s = new String(ch,0,2);
System.out.println(s);
}
/*
* String 构造方法，带有1个参数
* 字符数组 char[]
* 将字符数组转成字符串
* 不查询，编码表
*/
public static void method_3(){
//定义字符数组
char[] ch = {'a','b','c','d'};
//创建String对象，传递字符数组
String s = new String(ch);
System.out.println(s);
}
/*
* String 构造方法，带有3个参数
* 字节数组，int，int
* 查询平台默认编码表，将字节数组转成字符串
* 第一个int，开始下标，第二个int，获取几个
* 将字节数组的一部分，转成字符串
*/
public static void method_2(){
//定义字节数组
byte[] bytes = {97,98,99,100,101};
//创建String对象，调用构造方法，传递三个参数
String s = new String(bytes,0,2);
System.out.println(s);
}
/*
* String 构造方法，带有1个参数，字节数组
* byte[] = {};
* 将一个字节数组，转成字符串
* 采用平台(操作系统)默认字符集，解码字节数组
* 字节数组中的每个元素，查询编码表
* 编码表 GBK
* 负数开头，表示汉字 一个汉字2个字节
*
* 互联网中，网线，网卡，传输数据 byte
*/
public static void method_1(){
//定义字节数组 -128 - 127
byte[] bytes = {97,98,99,100};
//创建String对象，传递字节数组
String s = new String(bytes);
System.out.println(s);
byte[] bytes1 = {-60,-35,-67,-60};
String s1 = new String(bytes1);
System.out.println(s1);
}
/*
* String 空参数构造方法
* new String()
*/
public static void method(){
String s = new String();
System.out.println(s);
}
}
特别注意:字符串是一个常量,只要创建,之后就不能修改
定义方式，两种
|-- 直接定义 String s = ""
|-- new方法 String s = new String("")
|-- 定义方法区别
字符串的底层结构--特性
|-- private final char[] value 字符串就是一个字符数组
|-- String字符串，是一个常量，不可以改变
|-- 字符串面试题。引用类型中，数组，类类型，接口，都会改变，唯一就String不变
构造器
|-- 字节数组变成字符串， new 传递字节数组，查询编码表
|-- 字符数组变成字符串， new 传递字符数组，不查询编码表
判断方法
|-- equals 重写Object方法，比较字符串是不是完全相等
|-- equalsIgnoreCase 比较字符串是不是完全相等，忽略大小写
|-- contains 判断一个字符串是不是包含另一个字符串
|-- isEmpty 判断是不是空串
|-- startsWith 判断一个字符串是不是以另一个字符串开头
|-- endsWith 判断一个字符串是不是以另一个字符串结尾
获取方法
|-- charAt 指定索引返回单个字符
|-- indexOf 指定字符，返回第一次出现的索引
|-- lastIndexOf 指定字符，返回最后一次出现的索引
|-- length 返回字符串中字符个数
|-- substring 获取字符串一部分，包含头，不包含尾
转换方法
|-- getBytes 查询编码表，将字符串转成字节数组
|-- toCharArray 不查询编码表，将字符串转成字符数组
|-- toUpperCase 字符串转成大写
|-- toLowerCase 字符串转成小写
其他方法
|-- split 切割字符串
|-- replace 替换字符串
|-- trim 去掉两端空格
|-- compareTo 字典顺序比较字符串，又成为自然顺序
StringBuffer类 它的出现是为了提高字符串的操作效率,底层原理都是字符数组,是一个可变的字符序列,也可称为可变长度的字符数组,它可以通过数组的赋值,实现可变数组,而数组本身不能改变长度.字符缓冲区的默认长度为16.它的线程不安全就,即多个程序一起使用同一个StringBuffer类的时候,不会出现数据出错的情况,但是运行速度较慢.
构造方法有两种:一种是带有String类型参数的构造方法,一种是空参构造方法,主要是为了创建字符缓冲区对象
StringBuffer类的方法:
StringBuffer insert(int index,任意类型)//将任意数据，插入到缓冲区中的莫一个索引上
//下面的方法是将任意类型的数据,存储到缓冲区内,返回的是StringBuffer对象
StringBuffer append(任意)
append(){
return this;
}
以下为StringBuffer类的其他方法,包括删除,修改,反转,截取一部分,还有将缓冲区编程字符串
public class StringBufferDemo4 {
public static void main(String[] args) {
method_4();
}
/*
* 将缓冲区变成字符串
* 由一个可变的对象，转成不可变对象
* String toString()
*/
public static void method_4(){
StringBuffer buffer = new StringBuffer();
buffer.append("abcdefgh");
//将缓冲区，变成不可变对象String，缓冲区的toString()
String s = buffer.toString();
System.out.println(s);
}
/*
* 截取缓冲区一部分
* String substring(int start ,int end)
* 返回新的字符串，不是缓冲区
*/
public static void method_3(){
StringBuffer buffer = new StringBuffer();
buffer.append("abcdefgh");
//获取0，4下标
String s = buffer.substring(0, 4);
System.out.println(s);
}
/*
* 反转字符串缓冲区
* reverse()
* 定义功能，实现缓冲区的反转
* 核心，数组反转
*/
public static void method_2(){
StringBuffer buffer = new StringBuffer();
buffer.append("abcdefgh");
System.out.println(buffer);
//调用reverse反转
buffer.reverse();
System.out.println(buffer);
}
/*
* 修改缓冲区中的单个字符
* void setChatAt(int index,char ch)
*/
public static void method_1(){
StringBuffer buffer = new StringBuffer();
buffer.append("abcdefgh");
//修改第3索引上的字符，修改成#
buffer.setCharAt(3, '#');
System.out.println(buffer);
}
/*
* 缓冲区的删除
* delete(int start,int end)删除指定开始下标，到结束下标的内容
* deleteCharAt(int index) 删除指定下标上的1个字符
*/
public static void method(){
StringBuffer buffer = new StringBuffer();
buffer.append("abcdefgh");
//删除1个字符 deleteCharAt
//buffer.deleteCharAt(1);
//删除指定索引之间的字符
//包含头，不包含尾
buffer.delete(0, 4);
System.out.println(buffer);
}
}
注意:在JDK1.5中出现了一个新的类,StringBuilder类,它的方法和用法与StringBuffer类完全相同,区别就在于StringBuffer类是线程安全的,而StringBuilder类是线程不安全的.而线程安全的类运行速度慢,相反,不安全的运行速度快.
Arrays数组工具类 顾名思义,它主要是提供一系列对数组操作方法的工具类,其中的方法都是静态的,包括数组排序,包括选择排序和冒泡排序,还有折半查找法.需要注意的是,选择折半查找时,必须保证数组是有序的.以及toString()方法和asList()方法.
<span style="font-size:18px;">public class ArrayDemo {
public static void main(String[] args) {
int[] arr = {0,52,64,13,-12,61 ,61,6,-2,32};
//bubbleSort(arr);
printArr(arr);
int[] arr1 = {2,5,8,12,56,56,89,90};
int index = binarySearch(arr1,-2);
System.out.println(index);
}
/*
* 数组的折半查找功能
* 返回索引，传递数组，和被找的元素
*/
public static int binarySearch(int[] arr, int key){
//定义三个变量，保存数组的最小，最大，和中间索引
int min = 0 ;
int max = arr.length - 1;
int mid = 0;
//确定中间下标前提，数组有可能折半的时候，才能有中间下标
//开始循环折半
while(min <= max){
//计算中间索引
mid = (min+max)/2;
//用中间索引，可关键字进行比较
if(key > arr[mid])
min = mid + 1;
else if ( key < arr[mid])
max = mid - 1;
else
return mid;
}
return -1;
}
/*
* 定义方法：
* 实现数组的冒泡排序
*/
public static void bubbleSort(int[] arr){
for(int x = 0 ; x < arr.length ; x++){
for(int y = 0 ; y < arr.length -1 - x;y++){
if(arr[y] > arr[y+1]){
swap(arr,y,y+1);
}
}
}
}
/*
* 定义方法：
* 实现数组的选择排序，使用int数组，参数传递数组
* 嵌套循环
* 第一次 x = 0
* y = 1 2 3
* 第二次 x = 1
* y = 2 3
*/
public static void selectSort(int[] arr){
for(int x = 0 ;x < arr.length ; x++){
for(int y=x+1 ; y<arr.length ; y++){
if(arr[x] > arr[y]){
swap(arr,x,y);
}
}
}
}
/*
* 定义方法，实现数组的换位置
*/
private static void swap(int[] arr,int x,int y){
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
public static void printArr(int[] arr){
System.out.print("[");
for(int x = 0 ; x < arr.length; x++){
if(x==arr.length-1)
System.out.print(arr[x]);
else
System.out.print(arr[x]+",");
}
System.out.println("]");
}
}</span>
Integer类 基本数据类型类,对于8个基本数据类型,提供了8个类,将其封装为8个对象.其中提供了更多的方法和属性,来操作基本数据类型.其中最常见且应用最广泛的方法是其静态方法parseInt(String s)方法,可将数字格式的字符串转换为基本数据类型int
这其中需要介绍一个JDK1.5的新特性
自动装箱-- 自动将基本数据类型，变成对象
自动拆箱-- 自动将对象转成回基本数据类型
1462
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
