java基础题代码及一些小知识

---

重写equals()方法 和toString（)方法

在类中定义两个属性

	private int orderId;
	private String orderName;

重写equals()代码具体如下

@Override
	public boolean equals(Object obj) {
		if(this==obj){
			return true;
		}
		
		if(obj instanceof Order){
			Order o=(Order) obj;
			return this.getOrderName().equals(o.getOrderName())&&this.orderId==o.orderId;
			
			
			//不要这样写，String赋值方式不一样，会出现错误
//			return this.getOrderName()==o.getOrderName()&&this.orderId==o.orderId;
		}
		return false;
	}

一般的equals()方法都被重写过，Object类中未被重写过的equals()方法本质上和"=="一样。

重写toString()方法的具体代码如下

@Override
	public String toString() {
	return "姓名为："+orderName+"\t身份证号为:"+orderId;

没有重写过的toString()方法，输出的是地址值。

---

"=="和equals（）的区别

“==”	equals()
如果比较的值是基本数据类型，则比较的是具体值；如果比较的是引用数据类型，则比较的是地址值。	Object类中的一个方法，只适用于引用数据类型，equals()本质上与“==”一样，我们所调用的equals()方法一般都是String类重写过的equals()方法。

单例设计模式

单例设计模式是指采取一定的方法保证在整个软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。

饿汉式

public class Test {
	public static void main(String[] args) {
		Bank b=Bank.getBank();
		Bank b1=Bank.getBank();
		System.out.println(b==b1);
	}
}
class Bank{
	private Bank(){
		
	}
	static Bank bank=new Bank();
	public static Bank getBank(){
		return bank;
	}
}

上图可看出，饿汉式结果为true，说明指向了同一个地址值。

懒汉式

懒汉式需要考虑线程安全问题，有两种方式：同步方法和同步代码块

class Bank1{
        private Bank1(){

        }
        private static Bank1 instance=null;
        public static Bank1 getInstance() {
            if (instance == null) {
                synchronized (Bank1.class) {
                    if (instance == null) {//效率好
                        instance = new Bank1();
                    }

                }
            }
            return instance;
        }

上述代码相较于下边的效率稍好点

private Bank() {

    }

    private static Bank instance = null;
   	//方式一,同步方法
    //    public static synchronized Bank getInstance(){
 
    public static Bank getInstance() {
        synchronized (Bank.class) {//方式二，同步代码块
            if (instance == null) {//效率稍差
                instance = new Bank();
            }
            return instance;
        }
    }
}

将一个字符串中的指定部分进行反转

/*
* 将一个字符串进行反转。将字符串中指定部分进行反转。
* */
 
 
 
// 方法一，将字符串转换为char[]，进行反转
 
    public String reverse(String str,int startIndex,int endIndex){
 
       if(str!=null){        //判断传入方法中的字符串是否为空
 
           char[] arr=str.toCharArray();//使用String 类的toCharArrray()方法，将字符串传转换为char[]
 
           for (int x=startIndex,y=endIndex;x<y;x++,y--){//两个指针分别从需要进行反转的字符串的第一位和最后一位进行反转
 
               char temp=arr[x];
 
               arr[x]=arr[y];
 
               arr[y]=temp;
 
           }
 
           return new String (arr);//将反转后的char[]转换为String字符串，并输出
 
       }
 
        return null;//如果传入字符串为空，返回空
 
    }
 
 
 
 
 
 
 
// 方法二：使用String 的拼接操作对部分字符串进行反转
 
//因为String具有不可变性，该方法内存消耗较大，需要不断地进行创建、回收。
 
    public String reverse1(String str,int startIndex,int endIndex){
 
        if(str!=null){
 
            // 第一部分，通过String的substring方法获取需要反转部分前的字符串
 
            String substring = str.substring(0, startIndex);
 
 
 
        // 第二部分，通过for循环对需要进行反转部分进行反转
 
            for (int i = endIndex; i >=startIndex ; i--) {
 
                substring +=str.charAt(i);
 
            }
 
 
 
        // 第三部分，获取需要反转部分后的字符串
 
            substring+=str.substring(endIndex+1);
 
            return substring;
 
        }
 
        return null;
 
    }
 
 
 
 
 
 
//方式三 ：方式二的优化，使用StringBuffer、StringBuilder替换String
 
public String reverse2(String str,int startIndex,int endIndex){
 
        if(str!=null){
 
// 指定StringBuilder的容量
 
            StringBuilder builder=new StringBuilder(str.length());
 
 
 
// 第一部分
 
            builder.append(str.substring(0,startIndex));
 
// 第二部分
 
            for (int i = endIndex; i >=startIndex ; i--) {
 
                builder.append(str.charAt(i));
 
            }
 
// 第三部分
 
            builder.append(str.substring(endIndex+1));
 
            return builder.toString();
 
        }
 
        return null;
 
}

获取两串字符串中最大的相同字符串

 /*
 此代码前提是只有一个最大字符串
*/
    public String getMaxSameString(String str1,String str2){
        String maxStr = (str1.length() >= str2.length()) ? str1 : str2;
        String minStr = (str1.length() < str2.length()) ? str1 : str2;
        int length = minStr.length();
        for(int i=0;i<length;i++){
            for(int x=0,y=length-i;y<length;x++,y++){
                String substring = minStr.substring(x, y);
                if(maxStr.contains(substring)){
                    return substring;
                }
            }
        }
 
        return null;
    }
 
@Test
    public void test1(){
        String string1="absshoasgnhellosndxbhw";
        String string2="xbhssgnhelloxv";
        String maxSameString = getMaxSameString(string1, string2);
        System.out.println(maxSameString);
}
 

代码实现结果如下:

获取一个字符串在另一个字符串中出现的次数`

方式一

public int getCount(String mainStr,String subStr){
        int mainLength=mainStr.length();
        int subLength = subStr.length();
        int count=0;
        int index=0;
        if(mainLength>=subLength){
            while ((index=mainStr.indexOf(subStr))!=-1){
                count++;
                mainStr=mainStr.substring(index+subStr.length());
            }
            return count;
        }else{
            return 0;
        }
    }

方式二

public int getCount1(String mainStr,String subStr){
        int mainLength=mainStr.length();
        int subLength = subStr.length();
        int count=0;
        int index=0;
        if(mainLength>=subLength){
            while ((index=mainStr.indexOf(subStr,index))!=-1){
                count++;
                index+=subLength;
            }
            return count;
        }else{
            return 0;
        }
    }

}

采用单元测试的方法测试两种方法

    @Test
    public void test1(){
        String str1="asnidhsasbscasbckhioasnasas";
        String str2="as";
        int count = getCount(str1, str2);
        System.out.println(count);
        int count1 = getCount1(str1, str2);
        System.out.println(count1);
    }