数组
Java提供了一种叫作数组的数据结构,它是一种用来存储相同类型元素的固定大小顺序集合。 数组用于存储数据集合,但也可以将数组视为相同类型的变量集合。
可以是一维甚至多维。
数组变量本身属于引用类型,数组也可以看成对象(同样可以通过 new 实例化对象),数组中每一个元素相当于对象成员本身,存放于内存的堆空间中。
数组的声明
语法:
dataType[] arrayRefVar;
实例:
int[] arr;
语法:
dataType[] arrayRefVar = {value0, value1, ..., valuek};
实例:
int[] arr = {1, 2, 3, 4, 5}
语法:
dataType[] arrayRefVar = new dataType[arraySize];
实例:
int[] arr = new int[2];
int[][] arr2 = new int[2][2]; // 二维数组
说明:使用 new 关键字创建数据默认根据数组长度在开辟内存空间的提示赋值默认为 0。
1. 遍历数组
public class Main{
public static void main(String[] args){
String[] arr = {"10","20","30"};
int length = arr.length;
System.out.print(length);
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
for (int i = arr.length - 1; i >= 0; i--) {
System.out.println(arr[i]);
}
}
}
2. 数组最值
public class Main{
public static void main(String[] args){
int[] arr = {10,20,30,40};
int a = arr[0];
for (int i = 1; i < arr.length; i++) {
if(arr[i] > a){
// if(arr[i] < a){
a = arr[i];
}
}
System.out.print("最大(小)值:"+a)
}
}
3. 数组倒叙
public class Main{
public static void main(String[] args){
int[] arr = {10,20,30,40};
for (int i = 0; i < arr.length/2; i++) {
// 首位互换
int a = arr[i];
arr[i] = arr[arr.length-1-i];
arr[arr.length-1-i] = a;
}
System.out.print(Arrays.toString(arr))
}
}
4. 二分查找
前提:
public class Main{
public static void main(String[] args) {
int[] arr = {10, 20, 30, 30, 40, 50, 60, 70, 80, 90};
int index = search(arr, 70);
System.out.println(index);
}
public static int search(int[] arr, int num) {
int min = 0;
int max = arr.length - 1;
int center = (min + max) / 2;
while (min <= max) {
if (num == arr[center]) {
return center;
} else if (num > arr[center]) {
min = center + 1;
} else {
max = center - 1;
}
center = (min + max) / 2;
}
return -1;
}
}
fill
import java.util.Arrays;
public class Main{
public static void main(String[] args){
int[] arr = {2,3,5,8,41,85,11};
// Arrays.fill(arr,0); // 全部填充
Arrays.fill(arr, 2, 4, 0); // 指定位置填充
System.out.println(Arrays.toString(arr)); //=> [2, 3, 0, 0, 8, 85, 11]
}
}
toString
import java.util.Arrays;
public class Main{
public static void main(String[] args){
int[] arr = {2,3,5,8,41,85,11};
System.out.println(Arrays.toString(arr)); //=> [2, 3, 5, 8, 41, 85, 11]
}
}
import java.util.Arrays;
public class Main{
public static void main(String[] args){
int[] arr = {2,3,5,8,41,85,11};
printArr(arr)
}
// toString
public static void printArr(int[] arr){
for(int i = 0; i < arr.length; i++){
if(i==0){
System.out.print("[");
}
if(i==arr.length -1){
System.out.print("]");
}else{
System.out.print(arr[i]+', ');
}
}
}
}
sort
import java.util.Arrays;
public class Main{
public static void main (String[] args){
int[] arr = {2,3,5,8,41,85,11};
Arrays.sort(arr); //=> 类工具冒泡排序,不会进行返回。
System.out.print(Arrays.toString(sort));
}
}
import java.util.Arrays;
public class Main{
public static void main (String[] args){
int[] arr = {2,3,5,8,41,85,11};
int[] sort = sort(arr);
System.out.print(Arrays.toString(sort))
}
public static int[] sort(int[] arr){
int temp = 0;
// 执行多少次
for(int i = 0; i < arr.length-1; i++){
boolean flag = false;
// 每执行一次就少一层
for(int j = 0; j <arr.length-1-i;j++){
if(arr[j+1]>arr[j]){
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
flag = true;
}
}
if(flag==false){
break;
}
}
return arr;
}
}
在java6中,有一个方法Arrays.copyOf(),是一个泛型函数。我们可以利用它,写出更通用的合并方法:
public static <T> T[] concat(T[] first, T[] second) {
T[] result = Arrays.copyOf(first, first.length + second.length);
System.arraycopy(second, 0, result, first.length, second.length);
return result;
}
如果要合并多个,可以这样写:
public static <T> T[] concatAll(T[] first, T[]... rest) {
int totalLength = first.length;
for (T[] array : rest) {
totalLength += array.length;
}
T[] result = Arrays.copyOf(first, totalLength);
int offset = first.length;
for (T[] array : rest) {
System.arraycopy(array, 0, result, offset, array.length);
offset += array.length;
}
return result;
}
使用如下:
String[] both = concat(first, second);
String[] more = concat(first, second, third, fourth);
还可以使用:Array.newInstance来生成数组
private static <T> T[] concat(T[] a, T[] b) {
final int alen = a.length;
final int blen = b.length;
if (alen == 0) {
return b;
}
if (blen == 0) {
return a;
}
final T[] result = (T[]) java.lang.reflect.Array.
newInstance(a.getClass().getComponentType(), alen + blen);
System.arraycopy(a, 0, result, 0, alen);
System.arraycopy(b, 0, result, alen, blen);
return result;
}