day&day

 

选择排序

for (int i = 0; i < arr.length-1; i++) {

for (int j = i+1; j < arr.length; j++) {

if (arr[j]>arr[i]) {

arr[j]=arr[i]^arr[j];

arr[i]=arr[j]^arr[i];

arr[j]=arr[i]^arr[j];

}

}

}

 

 

冒泡排序

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]) {

arr[j]=arr[j]^arr[j+1];

arr[j+1]=arr[j]^arr[j+1];

arr[j]=arr[j]^arr[j+1];

}

}

}

 

/*
单例设计模式：

懒汉单例设计模式(线程安全问题 的解决方案):
步骤：
1. 私有化构造函数。
2. 声明本类引用类型变量，但是不要创建对象。
3. 声明一个公共静态的方法获取本类的对象，获取之前先判断是否已经创建了本类的对象了，如果已经创建了
就不要在创建直接返回即可，如果还没有创建，那么就先创建本类的引用类型变量，然后再返回。

*/

//懒汉单例设计模式
class Single{

// 声明本类引用类型变量，但是不要创建对象。
private static Single s;

　　//私有化构造函数
　　private Single(){}

　　// 声明一个公共静态的方法获取本类的对象
　　public static Single getInstance(){
　　　　if(s==null){
　　　　　　synchronized ("锁") {
　　　　　　if(s==null){
　　　　　　s = new Single();
　　　　　　　　}
　　　　　　}
　　　　}
　　return s;
　　}

}

 

/*
内存泄露

需求：编写一个类使用数组模拟堆栈的存储方式。

堆栈存储特点： 先进后出，后进先出。

注意： 不再使用的对象，应该不要让变量指向该对象，要让该对象尽快的被垃圾回收期回收。

*/
class StackList{

　　Object[] elements;

　　int index = 0 ; //当前的索引值

　　public StackList(){
　　this.elements = new Object[3];
}

//添加内容
public void add(Object o){
　　//添加元素之前应该要先检查是否容量够用。
　　ensureCapcity();
　　elements[index++] = o;
}


//出栈: 删除集合的元素，并且返回。
public Object pop(){
　　int tempIndex = --index;
　　Object o = elements[tempIndex];
　　elements[tempIndex] = null; //让该位置不再 引用着指定的对象,让垃圾回收期赶快回收该垃圾。
　　return o;
}


//检查当前的数组使用够用。
public void ensureCapcity(){
　　if(index==elements.length){
　　//计算一个新的长度
　　int newLength = elements.length*2;
　　elements = Arrays.copyOf(elements, newLength);
}
}

//获取当前的元素 个数
public int size(){
　　return index;
}

}