数组的一些知识点和插入选择冒泡排序

package test.sghuzu;

import java.lang.reflect.Array;
import java.util.Arrays;

public class Test1 {
/**
Java中的内存分配
Java程序在运行时，需要在内存中分配空间。
为了提高效率，对每一片空间都进行了划分，因为每一片1区域都有特定的处理数据方式和内存管理方式

栈 存储局部变量
堆 存储new出来的东西
方法区 暂时不管
本地方法区 系统有关，不管
寄存器 给CPU使用，也不管

局部变量，在方法中定义或者方法中声明的变量都是局部变量

栈内存的特点：
每一个new出来的东西都有地址值
每一个变量都有默认值
byte,short,int,long 0
float,double 0.0
char '\u0000'
boolean false
使用完毕就变成了垃圾，但是并没有立即回收。会在垃圾回收器空闲的时候回收
栈内存中的值数据用完就释放掉。
*/

/*
数组声明：
数据类型[] 数组名;
数据类型 数组名[];
两种方式效果一样，读法不同，第一个叫做一个名为数组名的数据类型数组，第二种叫做一个数据类型的 数组变量数组名。第二种更早，现在一般用第一种

数组的初始化：
两种初始化方式的区别在于数组的长度。第一种是自己固定数组长度，初始值由系统的默认值填充；第二种是自己固定数组的值，数组的长度由系统根据数组的值确定
动态初始化：
例子： int[] arr=new int[3];
静态初始化：
例子：int[] arr=new int[]{1,2,3};
上面这种形式不常用了，我们一般喜欢使用它的简写形式：
int[] arr={1,2,3};

值得注意的是：静态初始化数组实际上也是new声明的，不过是在声明赋了初始默认值后使用你给的值替代原来的默认值。和一些数组长度的不同控制

数组的遍历，数组中的元素使用下标来指定并做一系列操作。数组名.length得到数组的长度。

*/

/*
* 求最值：
以求最大值为例，选出一个数组中的值为参照物，依次使用其他的数组元素和它进行比较，比它大的取代它和剩下的元素进行比较，剩下的就是最大的元素了
*/
/*
逆序：
新建一个类型和长度都和原数组相同的数组，for循环依次输出原数组的元素，并将元素赋值给新数组位置为数组长度-旧数组现在下标位置的元素
*/
/*
数组中元素从大到小排序
*/
public static void main(String[] args){
int[] arr=new int[]{43,12,46,23,45,12,98};

/*int[] arr1=rebackArr(arr);
iteratorArrForEach(arr);
System.out.println();
iteratorArr(arr1);*/

/*int[] arr1=SortMaxToMin(arr);
iteratorArrForEach(arr);
System.out.println();
iteratorArr(arr1);*/
iteratorArrForEach(arr);

//SortMaxToMin3(arr);
System.out.println();
iteratorArrForEach(arr);

}

public static void iteratorArr(int[] arr){
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+"\t");
}
}
public static void iteratorArrForEach(int[] arr){
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+"\t");
}
}

public static int getMax(int[] arr){
int max=arr[0];

for(int i=1;i<arr.length;i++){
if(arr[i]>arr[i-1]){
max=arr[i];
}
}
return max;
}

public static int getMin(int[] arr){
int min=arr[0];

for(int i=1;i<arr.length;i++){
if(arr[i]<arr[i-1]){
min=arr[i];
}
}
return min;
}

public static int[] rebackArr(int[] arr){
int[] arr1=new int[arr.length];
for(int i=0,j=arr.length-1;i<arr.length;i++,j--){
arr1[i]=arr[j];
}
return arr1;
}

public static int[] SortMaxToMin(int[] arr){
/**
* 利用的是前面求最值的思路，应该是选择排序吧！
*
*/
/**
* 一般进行数组的排序都将改变原来数组的位置。因为数组是引用数据类型，针对同一个堆内存地址的改变。所以需要将原来数组的元素全部放入另一个数组之内
* ，操作另一个数组进行排序才会不改变原来数组。注意，新数组不能是调用原数组的引用
*/
int[] arr1=Arrays.copyOf(arr, arr.length);
//iteratorArr(arr1);
//int[] arr1=new int[arr.length];
/*for(int i=0;i<arr.length;i++){
arr1[i]=arr[i];
}*/
for(int j=0;j<arr1.length;j++){
for(int i=j+1;i<arr1.length;i++){
if(arr1[i]>arr1[j]){
arr1[j]=arr1[j]^arr1[i];
arr1[i]=arr1[j]^arr1[i];
arr1[j]=arr1[j]^arr1[i];
}
}

}
return arr1;
}
public static int[] SortMaxToMin1(int[] arr){
/**
* 选择排序，第一个开始，元素与它右边的元素比较，大的向右跑，一轮下来，最大的数就是最后面的
* 接下来就是循环了，依旧进行一样的循环
*
for(int i=0;i<arr.length;i++){
for(int j=1;j<arr.length;j++){
if(arr[j]>arr[j-1]){
arr[j]=arr[j]+arr[j-1]-(arr[j-1]=arr[j]);

}
}
}

这样可以达到排序的效果，但有心你就可以发现，第一轮已经确定最后一个是最大的了，第二轮还进行判断的话就代码多余了，所以我们进行优化，每一轮比较的次数比上一轮少1
所以语法应该是这样的：
for(int i=0;i<arr.length;i++){
for(int j=1;j<arr.length-i;j++){
if(arr[j]>arr[j-1]){
arr[j]=arr[j]+arr[j-1]-(arr[j-1]=arr[j]);

}
}
}
*/
for(int i=0;i<arr.length;i++){
for(int j=1;j<arr.length-i;j++){
if(arr[j]>arr[j-1]){
arr[j]=arr[j]+arr[j-1]-(arr[j-1]=arr[j]);

}
}
}

return arr;
}

package test.sghuzu;

public class Test8 {//我的插入排序
public static void main(String[] args){
int arr[]={12,32,76,23,97,12,32,4};
for(int j=0;j<arr.length-1;j++){
for(int i=0;i<arr.length;i++){
if(arr[j]>arr[i]){
int temp=arr[j];
arr[j]=arr[i];
arr[i]=temp;
break;
}
}
}
for(int s:arr){
System.out.print(s+"\t");
}

}

}

/* 一些源码 */
//非基本类型
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
T[] copy = ((Object)newType == (Object)Object[].class)
? (T[]) new Object[newLength]
: (T[]) Array.newInstance(newType.getComponentType(), newLength);
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
//基本数据类型
public static int[] copyOf(int[] original, int newLength) {
int[] copy = new int[newLength];
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}

关于数组的声明和赋值：

public class Test {
public static void main(String[] args){
int[] i;
i=new int[]{1,2,3};
int[] j;
i=new int[3];
/**
int[] k;
k={1,2,3};

先声明，后赋值，本来是没有错的，但是int[] a={1,2,3};是一种简写形式，拆分了会报错。
Java中{}代表的而是代码块的意思，如果k={1,2,3};相当于将一个{1,2,3}的代码块赋值给数组，所以报错
*/

}

}

数组的逆序：

package test.sghuzu;

public class Test3 {
public static void main(String[] args){
int[] arr=new int[]{12,33,67,98,34,12,43,65,78};
/**
* 逆序
*/
reversed(arr);
System.out.println();
reversed2(arr);

}

public static void reversed(int[] arr){
for(int a:arr){
System.out.print(a+"\t");
}
System.out.println();
int length=arr.length;
for(int i=0;i<length/2;i++){//换length/2次
arr[i]=arr[i]^arr[length-i-1];
arr[length-1-i]=arr[i]^arr[length-1-i];
arr[i]=arr[i]^arr[length-1-i];

}
for(int a:arr){
System.out.print(a+"\t");
}
}

public static void reversed2(int[] arr){
for(int a:arr){
System.out.print(a+"\t");
}
System.out.println();
for(int i=0,j=arr.length-1;i<=j;i++,j--){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;

}
for(int a:arr){
System.out.print(a+"\t");
}
}

}

寻找数组元素：

package test.sghuzu;

import java.util.Scanner;

public class Test4 {
public static void main(String[] args){
Scanner input=new Scanner(System.in);
String a[]={"星期一","星期二","星期三","星期四","星期五","星期六","星期天","星期一","星期三"};
System.out.println("查找指定星期第一次出现的下标，-1表示不存在指定星期！");
System.out.println("请输入查找的第一次出现的星期：");
while(true){
try{
String s=input.next();
int x=findFirstIndex(a,s);
System.out.println(x);
break;
}catch(Exception e){
System.out.println("输入异常，请重新输入！");
}
}

}
public static int findFirstIndex(String[] arr,String content){
for(int i=0;i<arr.length;i++){
if(arr[i]==content||arr[i].equals(content)){
return i;
}
}

return -1;

}
public static int findFirstIndex2(String[] arr,String content){
int index=-1;
for(int i=0;i<arr.length;i++){
if(arr[i]==content||arr[i].equals(content)){
index=i;
break;
}
}

return index;

}

}

}