选择排序
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;
}
}