数组
1.一维数组的创建与使用
1.创建一维数组
1.1先声明,再用new运算符进行内存分配
语法格式
数组元素类型 数组名字[];
数组元素类型[] 数组名字（推荐）;
int[] arrar;
arrar=new int[4];//数组名字=new 数组元素类型[数组元素的个数]
使用new关键字为数组分配内存，整型数组中各个元素的值都为0
1.2声明的同时为数组分配内存
语法格式
数组元素类型 数组名 =new 数组元素的类型[数组元素的个数]
int[] momth=new int[12];
2.初始化一维数组
方式一 Int arr[]=new int[]{1,2,3,4,5}
方式二 Int arr[]={23,34}
3.使用一维数组
相关代码
int day[]={31,28,31,30,31,30,31,31,30,31,30,31};
遍历数组方式：
1.for循环
for(int i=0;i<12;i++){
System.out.println((i+1)+"月有"+day[i]+"天");
}
2.foreach循环
for(int i:day){
System.out.println((i+1)+"月有"+day[i]+"天");
}
2.二维数组的创建与使用
1.先声明，再用new运算符进行内存分配
声明元素类型 数组名字[][];
声明元素的类型[][] 数组名字;
Int maryy[][]
Maryy=new int[2][4] //两行四列 包含两个长度为四的一维数组
2.二维数组初始化
Type arrayname[][]={value1,value2...}
Type arrayname[][]=new type[][]{values....}
3.使用二维数组
int a[][]=new int[3][4];
for(int i=0;i<a.length;i++) { //遍历行
for(int j=0;j<a[i].length;j++) { //遍历列
System.out.print(a[i][j]);
}
System.out.println();
}
4.数组的基本操作
1.遍历数组
int a[][]=new int[][] {{1,2,3,4},{2,4,6,8},{1,3,5,7}};
for(int i=0;i<a.length;i++) { //a数组的长度，a数组里的元素本身也是一个数组
for(int j=0;j<a[i].length;j++) { //内数组的长度
System.out.print(a[i][j]);
}
System.out.println();
}
2.填充替换元素
可通过Array类的静态方法filll（）来对数组中的元素进行替换。
1. fill(int[] a,int value) (数组内元素全部替换）
int a[]=new int[5];
Arrays.fill(a,8); //将位置8替换成a
for(int i=0;i<a.length;i++) {
System.out.print(a[i]);//88888
2. fill(int[] a,int fromindex,int toIndex,int value)
int a[]=new int[] {1,2,3,4,5};
Arrays.fill(a,1,3,8);//toIndex不包括尾边界
for(int i=0;i<a.length;i++) {
System.out.print(a[i]);
}
System.out.println();//18845
}
3. 对数组进行排序
1.Array.sort(arr);
int a[]=new int[] {5,3,7,2,1,0};
Arrays.sort(a);
for(int i=0;i<a.length;i++) {
System.out.print(a[i]);
}
System.out.println();//012357
}
2. 复制数组
1.Arrays.copyOf(arr,arg);
int a[]=new int[] {5,3,7,2,1,0};
int[] newarr=Arrays.copyOf(a, 6);
for(int i=0;i<a.length;i++) {
System.out.print(newarr[i]); }
System.out.println();
2.copyOfRange(arr,int formIndex,int toindex)
int[] arr1= {1,3,5,7,9};
int[] arr2=Arrays.copyOfRange(arr1, 1, 4);//不包括边界
for(int i:arr1) {
System.out.print(i+" ");
}
System.out.println();//1 3 5 7 9
for(int i:arr2) {
System.out.print(i+" ");
}System.out.println();//3 5 7 不包括右边界
}
}
3. 数组查询
1. binarySearch(OBJECT[] ,OBJECT KEY)
int a[]=new int[] {5,3,7,2,1,0};
Arrays.sort(a);//{0,1,2,3,5,7}
int index=Arrays.binarySearch(a, 3);
System.out.println("3的索引位置为"+index);
2. binarySearch(Object[],int formIndex,int toIndex,Object key)
int a[]=new int[] {5,3,7,2,1,0};
Arrays.sort(a);//{0,1,2,3,5,7}
int index=Arrays.binarySearch(a, 0,4,3);//此处的查询范围不包括右边界
System.out.println("3的索引位置为"+index);//3的索引位置为3
4. 数组排序算法
1. 冒泡排序
1. 基本思想：冒泡排序的基本思想是对比相邻的元素值，如果满足条件就交换元素的值，把较小的元素移动到数组前面，
把大的元素移动到数组后面（也就是交换元素的位置），这样较小的元素就像气泡一样从底部上升到顶部
public class BubbleSort {
public static void main(String[] args) {
int[] array= {63,4,24,1,3,15};//初始化数组
BubbleSort sorter=new BubbleSort();//创建冒泡排序类的对象
sorter.sort(array);//调用类方法
}
public void sort(int[] array) { //公共方法定义在主类的下面
for(int i=1;i<array.length;i++) { //趟数
for(int j=0;j<array.length-i;j++) { //每趟比较的次数
if(array[j]>array[j+1]) { //将较大额数下沉，较小的数上升
int temp=array[j];
array[j]=array[j+1];
array[j+1]=temp;
}
}
}
showArray(array);
}
public void showArray(int[] array) {
for(int i:array) {
System.out.print(">"+i);
}
System.out.println();
}
2.直接选择排序（快速排序）
直接选择排序的基本思想是将指定排序位置与其他位置分别对比，如果满足条件就交换元素的值，注意这里区别冒泡排序，不是交换相邻元素，而是把满足条件的元素与指定的排序位置交换。
1.通过内循环找到数组中的最大数的坐标
for(int j=1;j<=array.length-i;j++) {
if(array[j]>array[index]) {
index=j;//第一次找到的数是1
}
2.将找到的坐标位置的数与最后一个数交换
int temp=array[array.length-i];//
array[array.length-i]=array[index];
array[index]=temp;
3.每次交换完之后将index都默认为0，重复之前的步骤，但是内循环的次数会相应的减少一次
注意：直接排序比冒泡排序要快
public class selectSort {
public static void main(String[] args) {
int[] array= {67,78,45,67,34,30};
selectSort sorter=new selectSort();
sorter.sort(array);
}
Public void sort(int[] array) {
int index;//最大值的编号
for(int i=1;i<array.length;i++) {
index=0;//内循环主要找到数组中最大的数的位子坐标
for(int j=1;j<=array.length-i;j++) {
if(array[j]>array[index]) {
index=j;
}
}
//找到位置坐标后，与数组的最后一个数交换
int temp=array[array.length-i];//
array[array.length-i]=array[index];
array[index]=temp;
}
showArray(array);
}
public void showArray(int[] array) {
for(int i:array) {
System.out.print(">"+i);
}
System.out.println();
}
}
3. 反转排序
反转排序就是以相反的顺序把原有的数组的内容重新排序。
int[] array= {23,45,67,89,12,34,65,2};
$1 sorter=new $1();
sorter.sort(array);
}
public void sort(int[] array) {
System.out.println("数组原有内容:");
showArray(array);
int temp;
int len=array.length;
for(int i=0;i<len/2;i++) {
temp=array[i];
array[i]=array[len-1-i];//建立外循环参数与内循环的联系a[0]-a[4]a[1]-a[3]
array[len-1-i]=temp;
}
System.out.println("数组反转后");
showArray(array);
}
public void showArray(int[] array) {
for(int i:array) {
System.out.print(" "+i);
}
System.out.println();
}
练习
1.编写程序，将数组中的最小的数找出来（此题注意数组超限)
int[] arr= {5,4,56,89,90};
int temp=0;
for(int i=1;i<arr.length;i++) {
if(arr[i]<arr[i-1]) { //此处i+1容易超限
temp=arr[i];
arr[i]=arr[i-1];
arr[i-1]=temp;
}
}
System.out.println(temp);//4
2.编写程序，将数组中位置索引为2的元素替换为“bb”
Object[] arr= {5,4,56,89,90,1,0,};//object保存引用对象的32位的地址，可以为Object的变量分配任何引用类型（字符串，数组，类，接口）
for(Object i:arr) {
System.out.print(i+" ");
}
System.out.println();
Arrays.fill(arr, 2,3,"bb");
for(Object i:arr) {
System.out.print(i+" ");
}
System.out.println();
3编写转置阵列
int [][] array= {{1,2,3},{4,5,6},{7,8,9}};
int array2[][]=new int[3][3];
$4 test=new $4();
test.showArrays(array);
test.transfer(array, array2);
System.out.println();
test.showArrays(array2);
}
public void showArrays(int[][] array) {
for(int i=0;i<array.length;i++) {
for (int j=0;j<array[i].length;j++) {
System.out.print(" "+array[i][j]+" ");
}
System.out.println();
}
}
public void transfer(int[][] array,int[][] array2) {
for(int i=0;i<array.length;i++) {
for(int j=0;j<array[i].length;j++) {
array2[i][j]=array[j][i];
}
}
}
}
二维数组的行列转置
public class Test {
public static void main(String[] args){
int a[][]= {{1,2,3},{4,5,6},{7,8,9}};
int count=0;
for(int i=0;i<a.length;i++) {
for(int j=i;j<a[i].length;j++) { //列 //每次从相等的位置来转换，就不会发生错误
int temp=a[i][j];
a[i][j]=a[j][i];
a[j][i]=temp;
}
}
for(int i=0;i<a.length;i++) {//行
for(int j=0;j<a[i].length;j++) { //列
System.out.print("["+a[i][j]+"] "+" ");
count++;
}
if(count%3==0) {
System.out.println();
}
}
}
}
数组的反转
public class Test {
public static void main(String[] args) {
int[] a = { 1, 2, 3, 4, 5, 6, 7 };// {,7,6,5,4,3,2,1}
for (int i = 0; i < a.length / 2; i++) {
int temp = a[i];
a[i] = a[a.length - i - 1];
a[a.length - 1 - i] = temp;
}
for (int i = 0; i < a.length; i++) {// 行
System.out.print("[" + a[i] + "] " + " ");
}
}
}
从字符串中提取出数字
public class Test {
public static void main(String[] args) {
System.out.println("请输入一段字符串，本程序将自动提取数字信息！！！");
Scanner input = new Scanner(System.in);
String s = input.nextLine();
byte[] arr = s.getBytes();//getBytes将字符串转换为字节数组
int count = count(arr);
byte[] na = new byte[count];
copy(arr, na);
String str = new String(na);//利用字符串的构造方法将字节数组转换为字符串
System.out.println(str);
}
public static int count(byte[] temp) {
int sum = 0;
for (int i = 0; i < temp.length; i++) {
if (temp[i] >= '0' && temp[i] <= '9') {
sum++;
}
}
return sum;
}
public static void copy(byte[] old, byte[] newster) {
int foot = 0;
for (int i = 0; i < old.length; i++) {
if (old[i] >= '0' && old[i] <= '9') {
newster[foot] = old[i];
foot++;
}
}
}
}