day08 Java 常见对象

最新推荐文章于 2020-01-31 13:51:08 发布

lwj_bj

最新推荐文章于 2020-01-31 13:51:08 发布

阅读量197

点赞数

分类专栏： Java基础知识

本文链接：https://blog.csdn.net/lwj_hewo/article/details/85978465

版权

本文详细介绍了Java中的基础对象概念，包括Object类的equals方法解析和子类重写示例。同时讲解了Scanner类的使用，以及String类和StringBuilder/StringBuffer的区别。还涵盖了数组排序算法、包装类、正则表达式、Math与Random类，以及Date和Calendar类的基本应用。

摘要由CSDN通过智能技术生成

1 Object类

类层次结构的根类，所有类都直接或者间接的继承自该类。

== ：

基本类型：比较的就是值是否相同

引用类型：比较的就是地址值是否相同

equals ：

引用类型：默认情况下比较的是地址值。重写时一般比较对象的成员变量值是否相同。

Object类equals方法源码：

public boolean equals(Object obj) {
        return (this == obj);
}

子类重写Object类equals 方法

public class Student implements Cloneable {
	private int age;
	private String name;

	private int getAge() {
		return age;
	}

	private void setAge(int age) {
		this.age = age;
	}

	private String getName() {
		return name;
	}

	private void setName(String name) {
		this.name = name;
	}

	public Student(int age, String name) {
		super();
		this.age = age;
		this.name = name;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj) {
			return true;
		}
		if (!(obj instanceof Student)) {
			return false;
		}
		Student s = (Student) obj;
		return this.name.equals(s.name) && this.age == s.age;

	}

	@Override
	protected Object clone() throws CloneNotSupportedException {
		// TODO Auto-generated method stub
		return super.clone();
	}
}

2 Scanner 类

JDK5以后用于获取用户的键盘输入。hasNextXxx() 判断是否还有下一个输入项,其中Xxx可以是Int,Double等，如果需要判断是否包含下一个字符串，则可以省略Xxx。nextXxx() 获取下一个输入项。

3 String类

字符串是由多个字符组成的一串数据(字符序列)，可以看成是字符数组。字符串是常量，它的值在创建之后不能更改。字符串缓冲区支持可变的字符串。

1 字符串拼接内存图解

2 String s=new String("hello")和String s="hello" 内存图解

String 类使用代码示例

public class StringTsst {

	public static void main(String[] args) {
		String s1=new String();
		System.out.println(s1);
        System.out.println(s1.length());//0
        byte[] bys= {97,98,99,100,101};
        String s2=new String(bys);
        System.out.println(s2);//abcde
        System.out.println(s2.length());//5
        char[] chs= {'a','b','c','d','e','我','是'};
        String s3=new String(chs);
        System.out.println(s3);//abcde我是
        System.out.println(s3.length());//7
        
        String s4="hello";
        s4 += "world";
        System.out.println(s4);//helloworld
        
        String s5=new String("hello");
        String s6="hello";
        //  ==:比较引用类型比较的就是地址值是否相同
        System.out.println(s5==s6);//false
        // equals:比较引用类型默认比较的是地址值是否相同，但是String类重写了equals方法，
        // 比较的是内容是否相同
        System.out.println(s5.equals(s6));//true
        
        String s7="world";
        String s8="helloworld";
        System.out.println(s8 == s6+s7);//false
        System.out.println(s8.equals(s6+s7));//true
        System.out.println(s8 == "hello"+"world");//true
        System.out.println(s8.equals("hello"+"world"));//true
        
        String s9="Hello123world";
        int big=0,small=0,num=0;
        for (int i = 0; i < s9.length(); i++) {
        	char ch=s9.charAt(i);
        	if('A'<= ch && ch<='Z') {
        		big++;
        	}else if('a'<= ch && ch<='z') {
        		small++;
        	}else if('0'<= ch && ch<='9'){
        		num++;
        	}

		}
        System.out.println("big:"+big+",small:"+small+",num:"+num);//big:1,small:9,num:3
        
        String s10="woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";
        String s11="java";
        System.out.println(getCount(s10, s11));//5
	}
    /**
      * 查找较长字符串中包含的较短字符串个数
     * @param maxStr 较长字符串
     * @param minStr 较短字符串
     * @return 个数 
     */
    public static int getCount(String maxStr,String minStr) {
        
    	int count=0;
    	int index;
    	while((index=maxStr.indexOf(minStr)) != -1){
    		count++;
    		maxStr=maxStr.substring(index+minStr.length());
    	}
		return count;   
    	
    }
}

4 StringBuffer 类

同步的，线程安全（多线程时）的可变字符序列。

public class StringBufferTest {

	public static void main(String[] args) {
		//无参构造
		StringBuffer sb=new StringBuffer();
		System.out.println(sb.capacity());//16
        System.out.println(sb.length());//0
        
        // public StringBuffer(int capacity) 指定容量的字符串缓冲区对象
        StringBuffer sb2=new StringBuffer(50);
        System.out.println(sb2.capacity());//50
        System.out.println(sb2.length());//0
        
        // public StringBuffer(String str) 指定字符串内容的字符串缓冲区对象
        StringBuffer sb3=new StringBuffer("hello");
        System.out.println(sb3.capacity());//21
        System.out.println(sb3.length());//5
        
        StringBuffer sb4=new StringBuffer();
        sb4.append("hello").append("world").append("java");
        sb4.deleteCharAt(1);
        System.out.println(sb4);//hlloworldjava
        sb4.delete(4, 9);
        System.out.println(sb4);//hllojava
        sb4.delete(0, sb4.length());
        System.out.println(sb4);
        sb4.insert(0, "helloworld");
        System.out.println(sb4);//helloworld
        sb4.replace(2, 5, "hhh");
        System.out.println(sb4);//hehhhworld
        sb4.reverse();
        System.out.println(sb4);//dlrowhhheh
        String s=sb4.substring(2, 5);
        System.out.println(sb4);//dlrowhhheh
        System.out.println(s);//row
        
        String s1="hello";
        String s2="world";
        System.out.println(s1+"---"+s2);//hello---world
        chage(s1,s2);
        System.out.println(s1+"---"+s2);//hello---world
        
        StringBuffer sb5=new StringBuffer("hello");
        StringBuffer sb6=new StringBuffer("world");
        System.out.println(sb5+"---"+sb6);//hello---world
        chage(sb5,sb6);
        System.out.println(sb5+"---"+sb6);//hello---worldworld
	}

	private static void chage(StringBuffer sb1, StringBuffer sb2) {
		sb1=sb2;
	    sb2.append(sb1); 
	}

	private static void chage(String s1, String s2) {
		s1=s2;
		s2=s1+s2;
		
	}

}

5 StringBuilder 类

不同步的，线程不安全（多线程时）的可变字符序列。StringBuffer的一个简易替换，用在字符串缓冲区被单个线程使用时。在大多数实现中，比StringBuffer要快。

6 数组相关算法

1 冒泡排序

相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处。

	/**
	 * @param arr 需要排序的数组
	 * 冒泡排序
	 */
	private static void bubbleSort(int[] arr) {
		
		for (int i = 0; i < arr.length-1; i++) {
			for (int j = 0; j < arr.length-1-i; j++) {
				if(arr[j]>arr[j+1]) {
					int temp=arr[j];
					arr[j]=arr[j+1];
					arr[j+1]=temp;
				}
			}
		}
		
	}

2 选择排序

从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处。

	/**
	 * @param arr 需要排序的数组
	 * 选择排序
	 */
	private static void selectSort(int[] arr) {
		for (int i = 0; i < arr.length-1; i++) {
			for (int j = i+1; j < arr.length; j++) {
				if(arr[j]<arr[i]) {
					int temp=arr[j];
					arr[j]=arr[i];
					arr[i]=temp;
				}
			}
		}
		
	}

3 二分查找（数组元素有序）

步骤：

A:定义最大索引，最小索引：min=0 max=arr.length-1
B:计算出中间索引: mid=(min+max)/2
   C:拿中间索引的值和要查找的值进行比较
相等：就返回当前的中间索引
   不相等：
   大   左边找
   小   右边找
   D:重新计算出中间索引
   大   左边找
   max = mid - 1;
   小   右边找
min = mid + 1;
      E:回到B

	/**
	 * @param arr 排序后的数组
	 * @param value 需要查找的数值
	 * 二分查找
	 */
	private static int binarySearch(int[] arr, int value) {
		int min=0,max=arr.length-1;
		int mid=(max+min)/2;
		while(arr[mid] != value) {
			if(arr[mid] > value) {
				max=mid-1;
			}else if(arr[mid] < value) {
				min=mid+1;
			}
			if(min>max) {
				return -1;
			}
			mid=(max+min)/2;
		}
		return mid;
	}

7 包装类

为了对基本数据类型进行更多的操作，更方便的操作，Java就针对每一种基本数据类型提供了对应的类类型。包装类类型。
byte Byte
short   Short
int Integer
long Long
float Float
  double Double
char   Character
boolean           Boolean

public class IntegerTest {

	public static void main(String[] args) {
		System.out.println(Integer.MAX_VALUE);//2147483647
		System.out.println(Integer.MIN_VALUE);//-2147483648
		// 二进制
		System.out.println(Integer

最低0.47元/天解锁文章

lwj_bj

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
day08 Java 常见对象

1 Object类类层次结构的根类，所有类都直接或者间接的继承自该类。 == ：基本类型：比较的就是值是否相同引用类型：比较的就是地址值是否相同 equals ：引用类型：默认情况下比较的是地址值。重写时一般比较对象的成员...
复制链接

扫一扫

专栏目录