标签：bin 二分法查找 stat binary search idv rom oid 分配
一、数组的练习
1.声明一个char类型的数组， 从键盘录入6个字符: 【1】遍历输出 【2】排序 【3】把char数组转化成一个逆序的数组。
1 import java.util.Scanner; 2 public class Operation01{ 3 public static void main (String[] args){ 4 char[] zifu = new char[6]; 5 Scanner car = new Scanner(System.in); 6 char temp; 7 //从键盘上获取字符存放于数组中，并输出 8 for(int i=0;i <zifu.length;i++){ 9 System.out.println("请输入第"+(i+1)+"个字符"); 10 zifu[i] = car.next().charAt(0); 11 12 } 13 for(int i=0;i <zifu.length;i++){ 14 System.out.print(zifu[i]+"\t"); 15 } 16 //按照冒泡法排的序列 17 for(int i = 1;i < zifu.length;i++){ 18 for(int j =0;j < zifu.length-i;j++){ 19 if(zifu[j] >zifu[j+1]){ 20 temp = zifu[j]; 21 zifu[j] =zifu[j+1]; 22 zifu[j+1] = temp; 23 24 } 25 } 26 } 27 System.out.println(); 28 for(int i=0;i <zifu.length;i++){ 29 System.out.print(zifu[i]+"\t"); 30 } 31 //实现逆序输出 32 int a =zifu.length/2; 33 for(int i=0;i < a;i++){ 34 temp = zifu[i]; 35 zifu[i] = zifu[zifu.length-1-i]; 36 zifu[zifu.length-1-i] =temp; 37 } 38 System.out.println(); 39 for(int i=0;i <zifu.length;i++){ 40 System.out.print(zifu[i]+"\t"); 41 } 42 43 } 44 }
2.有一组数分别为18,25,7,36,13,2,89,63求出最小的值,并将最小的数与最小的数所在的下标输出。
1 public class Operation03{
2 public static void main (String[] args){
3 int[] arr ={18,25,7,36,13,2,89,63};
4 /*定义一个int变量min，把数组第1个元素
5 赋值给其，让min依次和数组后面的元素比较，
6 如果min比后面的元素大，则把这个元素的值付给它
7 否则依然是min等于数组第一个元素*/
8 int min =arr[0];
9 int loc = 0;
10 for(int i = 1;i <arr.length;i++){
11 if(min > arr[i]){
12 min = arr[i];
13 loc = i;
14 }
15 }
16
17 System.out.println("最小的值为："+min+"下标"+loc);
18 }
19 }
3.已知一个数组存在重复元素，请去掉数组中的重复元素。
1 public class Operation07{ 2 public static void main (String[] args){ 3 int[] arr ={1,1,1,6,3,4,5,0,0}; 4 int len = arr.length; 5 int cop; 6 for(int i = 0;i <len;i++){ 7 cop =arr[i]; 8 9 for(int j = i+1;j < len;j++){ 10 11 if(cop == arr[j]){ 12 //移动 13 for(int k =j;k <len-1;k++){ 14 arr[k] = arr[k+1]; 15 } 16 //移动完成后在末尾补0,并该变每一轮循环的次数 17 arr[len-1] = 0; 18 j--; 19 len--; 20 } 21 } 22 } 23 //为区分是否已删除末尾的0，遍历数组显示到len 24 for(int i = 0;i <len;i++){ 25 System.out.print(arr[i]+"\t"); 26 } 27 } 28 }
二、 命令行参数（C）
在程序运行过程中，可以向应用程序传递一些参数，这些参数称为命名行参数。
1 public class Test03{
2 public static void main (String[] args){
3 //获取字符串，保存于args[]中，并统计字符串的个数
4 System.out.println(args.length);
5 for(int i = 0;i < args.length;i++){
6 System.out.println(args[i]);
7 }
8 }
9 }
 |
命令行参数以字符串的形式传入args数组中。可以一次传递0-多个参数，以空格分割。
如果参数中本身包含空格，需要使用引号引起来。
三、Arrays类
jdk中为了便于开发，给开发者提供了Arrays，其中包含了很多数组的常用操作，例如：快速输出、排序、查找等。
常用方法
1 import java.util.Arrays;
2 public class Test04{
3 public static void main (String[] args){
4 int[] arr = {1,3,4,6,2,7};
5 // 【1】数组的字符串形式
6 System.out.println(Arrays.toString(arr));
7
8 //【2】sort对数组排序(只能升序)-> 内部使用快速排序。
9 Arrays.sort(arr);
10 System.out.println(Arrays.toString(arr));
11
12 //全部填充num,fill（arr,num）;
13 //Arrays.fill(arr,0);
14 //System.out.println(Arrays.toString(arr));
15 /*
16 判断两个数组是否相等
17 equals(arr1,arr2);
18 数组相等的条件:1.长度相等 2.对应位置元素相等。
19 */
20 int[] arr2 = {1,3,4,6,2,7};
21 System.out.println(Arrays.equals(arr,arr2));
22 }
23 }
二分法查找
1 private static int binarySearch0(long[] a, int fromIndex, int toIndex,
2 long key) {
3 int low = fromIndex;
4 int high = toIndex - 1;
5
6 while (low <= high) {
7 int mid = (low + high) >>> 1;
8 long midVal = a[mid];
9 if (midVal < key)
10 low = mid + 1;
11 else if (midVal > key)
12 high = mid - 1;
13 else
14 return mid; // key found
15 }
16 return -(low + 1); // key not found.
17 }
二分法查找的必须是有序的数组，如果找到返回索引；如果没有找到，返回-插入点-1。插入点就是key应该放到数组的位置。
数组的复制
copyOf(arr,len) 把arr复制len个长度的元素并返回新数组。如果len>arr.length,新数组的长度末尾用0填充。
copyOfRange(arr,from,to) 从arr中from(包含)位置开始复制到to(不包含)这个范围的元素到新数组中。含头不含尾。
1 import java.util.Arrays;
2 public class Test01{
3 public static void main (String[] args){
4 int[] arr = {1,3,4,6,2,7};
5 //copyOf(arr,length)
6 int[] newArr = Arrays.copyOf(arr,5);
7 System.out.println(Arrays.toString(newArr));
8 //copyOfRange(arr,form,to)
9 int[] newArr2 = Arrays.copyOfRange(arr,1,4);
10 System.out.println(Arrays.toString(newArr2));
11 }
12 }
System也提供了赋值数组的方法。
arraycopy(srcArr,srcPos,destArr,destPos,len)
srcArr:要复制的源数组；srcPos:从srcArr的srcPos位置开始复制；destArr:复制到的目标数组；destPos:目标数组从destPos开始存放；
len:从源数组中复制len个长度
int[] arr2 = new int[5];
System.arraycopy(arr,2,arr2,1,4);
System.out.println(Arrays.toString(arr2));
二维数组就是数组的数组，数组的元素也是数组。
|
二维数组表示二维的行列结构
二维数组的声明
1 import java.util.Arrays;
2 public class Test05{
3 public static void main(String[] args){
4
5 // 二维数组
6 //int[]
7 // (int[]) []
8
9
10 // 【1】声明
11 int[][] arr;
12 // 【2】初始化一个能存3个一维数组的二维数组
13 arr = new int[3][];
14
15 // 【3】赋值
16 int[] arr1 = {1,3,4,5};
17 int[] arr2 = {1,3,4};
18 int[] arr3 = {2,1,6,4};
19
20 arr[0] = arr1;
21 arr[1] = arr2;
22 arr[2] = arr3;
23
24 System.out.println(arr);
25 System.out.println(Arrays.toString(arr));
26 }
27 }
此时arr = new int[3][];只分配了二维数组的空间，一维数组没有分配空间。
声明一个规则的二维数组
import java.util.Arrays;
public class Test06{
public static void main(String[] args){
// 声明一个规则的二维数组，3行4列
int[][] arr;
arr = new int[3][4];
arr[0][0] = 10;
arr[0][1] = 20;
arr[0][2] = 30;
arr[0][3] = 40;
arr[1][0] = 100;
arr[1][1] = 200;
arr[1][2] = 300;
arr[1][3] = 400;
arr[2][0] = 1000;
arr[2][1] = 2000;
arr[2][2] = 3000;
arr[2][3] = 4000;
System.out.println(Arrays.toString(arr));
}
}
此时，二维数组已经分配好空间，同时一维也分配好空间。
当已知二维数组的值数，可以考虑字面量声明
import java.util.Arrays;
public class Test07{
public static void main(String[] args){
// 声明字面量二维数组
int[][] arr = {
{10,20,30,40},
{100,200,300},
{1000,2000,3000,4000}
};
System.out.println(Arrays.toString(arr));
}
}
二维数组的遍历
import java.util.Arrays;
public class Test02{
public static void main (String[] args){
int[][] arr = {
{10,20,30},
{100,200,300,400},
{1000,2000,3000}
};
/*
int[] temp;
for(int i=0;i <arr.length;i++){
temp = arr[i];
for(int j=0;j < temp.length;j++){
System.out.print(temp[j]+"\t");
}
System.out.println();
}
*/
for(int i = 0;i < arr.length;i++){
for(int j = 0;j < arr[i].length;j++){
System.out.print(arr[i][j]+"\t");
}
System.out.println();
}
}
}
五、基本数据类型和引用数据类型赋值的区别
基本数据类型赋值时，复制的是值
引用数据类型赋值时，复制的是引用。
public class Test09{
public static void main(String[] args){
// 基本数据类型的赋值
int a = 10;
int b;
b = a;
// a? b?
b = 20;
// a? b?
// 引用数据类型的赋值
int[] arr = {1,3,5};
int[] arr2 = arr;
arr2[0] = 100;
System.out.println("arr:"+arr);
System.out.println("arr2:"+arr2);
System.out.println("arr[0]:"+arr[0]);
}
}
|
标签：bin 二分法查找 stat binary search idv rom oid 分配
原文地址：https://www.cnblogs.com/ruckly/p/10732447.html
