Java(컬렉션) 기반 배열에 대한 일반적인 작업 요약

아래 편집기는 Java 기반의 배열의 일반적인 작업 요약을 제공합니다( 꼭 읽어보세요). 에디터가 꽤 좋다고 생각해서 지금 공유해서 참고용으로 올려보겠습니다. 편집기를 따라가며 살펴보겠습니다.

배열에서 일반적으로 사용되는 작업

1. 배열에서 최대값과 최소값 찾기

아이디어:아래 첨자 0이 있는 요소가 최대값, 라고 가정합니다. 배열 을 탐색하여 max와 차례로 비교합니다. max보다 큰 요소가 있으면 이 값을 max에 할당합니다. 최소값은 동일합니다.

public class TestArray{
  public static void main(String[] args){
    int[] arr={23,45,234,576,34,87,34,12,67};
    int max=arr[0];
    int min=arr[0];
    for(int i=0;i<arr.length;i++){
      if(arr[i]>max){
        max=arr[i];
      }
      if(arr[i]<min){
        min=arr[i];
      }
    }
    System.out.println("数组中最大值为:"+max);
    System.out.println("数组中最小值为:"+min);
  }
}

2. 배열에 요소가 존재하는지 확인

import java.util.Scanner;
public class TestArray{
  public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int[] arr={23,45,234,576,34,87,34,12,67};
    System.out.println("请输入你要查找的元素");
    int element=in.nextInt();
    int i,flag=0;
    for(i=0;i<arr.length;i++){
      if(arr[i]==element){
        flag=1;
        break;
      }
    }
    if(flag==1){
      System.out.println("你要查找的元素的下标为:"+i);
    }else{
      System.out.println("你要查找的元素不存在");
    }
  }
}

(2), 이진 검색 방법을 사용하여 요소가 있는지 확인하세요. 배열에 존재합니다.< /strong>

전제: 검색할 배열은 순서(크기순)이어야 합니다.

원리: 검색할 요소를 배열의 가운데 첨자 요소와 비교하고, 중간 요소보다 크면 오른쪽에서 검색하고, 중간 요소보다 작으면 왼쪽에서 검색합니다.

public static int binarySearch(int[] arr,int ele){
    int left=0;
    int right=arr.length-1;
    int mid;
    int index=-1;
    while(left<=right){
      mid=(left+right)/2;
      if(arr[mid]==ele){
        index=mid;
        break;
      }else if(arr[mid]<ele){
        left=mid+1;
      }else if(arr[mid]>ele){
        right=mid-1;
      }
    }
    return index;
  }

3. 배열 정렬

(1), 버블 정렬< /p>

원리: 인접한 요소를 비교하여 작은 요소는 앞으로 이동하고 큰 요소는 뒤로 이동하며 최대값이 가장 크게 나타납니다지수

분석: 처음 비교하면 나중에 더 큰 것이 나타나며, 최대값이 가장 큰 지수에 순위가 매겨집니다

두 번째 비교, 최대값이 정해져 있으므로 처음 n-1개의 요소만 비교하여 두 번째로 큰 인덱스에서 두 번째로 큰 값을 결정하면 됩니다

에서 세 번째로 큰 값과 네 번째로 큰 값을 결정합니다. 턴 값.............

결론: N개의 숫자가 나열되고, 작은 숫자가 앞쪽에 더 가깝게 배치됩니다. 외부 레이어루프n-1, 내부 루프 n-1-i

public class TestArray{
  public static void main(String[] args){
    int[] arr={10,3,8,1,6};
    //外层循环控制比较轮数
    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]){
          int temp=arr[j];
          arr[j]=arr[j+1];
          arr[j+1]=temp;
        }
      }
    }
    //遍历数组
    for(int i=0;i<arr.length;i++){
      System.out.println(arr[i]);
    }
  }
}

(2), 선택 정렬

원리: 아래 첨자 0부터 시작하여 다음 요소와 비교하세요. 다음 요소가 아래 첨자가 0인 요소보다 작으면 이를 바꿉니다. 인덱스가 0인 새 요소를 다음 요소와 비교합니다. 첫 번째 완료 후 최소값은 인덱스 0에 나타납니다.

예: {10, 3, 8, 1, 6}

첫 번째 비교 라운드는 0 아래 첨자 요소부터 시작하여 순차적으로 수행됩니다. 다음과 같이 요소를 비교하려면 먼저 10과 3, 10<3을 비교하고 위치를 바꾸면 아래 첨자 0이 있는 요소는 3, {3, 10, 8, 1, 6}이 되고 3과 8, 3<8을 비교합니다. , 전치 없음, 3과 1, 3>1, 전치

1, 10, 8, 3, 6}, 그런 다음 1과 6, 1<6을 비교하고 위치를 변경하지 않습니다. 첫 번째 라운드가 끝났습니다. {1, 10, 8, 3, 6}

두 번째 비교 라운드에서는 이전 라운드에서 아래 첨자 0이 있는 요소가 최소값이라고 결정했습니다. 이번 비교 라운드는 다음에서 시작됩니다. 아래 첨자 1, 먼저 10과 8을 비교하고 {1, 8, 10, 3, 6}을 전치하고 8과 3을 비교하고 {1, 3, 10, 8, 6}을 전치하고 3과 6을 비교하지만 비교하지는 않습니다. 바꾸어 놓다. 두 번째 라운드가 끝나면 끝에서 두 번째 요소가 첨자 1에 있는 것으로 결정됩니다.

........

전체 길이를 1라운드로 비교해보세요.

public class TestArray{
  public static void main(String[] args){
    int[] arr={10,3,8,1,6};
    for(int i=0;i<arr.length-1;i++){
      for(int j=i+1;j<arr.length;j++){
        if(arr[i]>arr[j]){
          int temp=arr[i];
          arr[i]=arr[j];
          arr[j]=temp;
        }
      }
    }
    //遍历数组
    for(int i=0;i<arr.length;i++){
      System.out.println(arr[i]);
    }
  }
}

4. 배열의 요소 삭제

(1) 아래 첨자에 따라 요소 삭제(공백은 0으로 채움)

< /p>

public static void delete(int[] arr,int index){
    for(int i=index;i<arr.length-1;i++){
      arr[i]=arr[i+1];
    }
    arr[arr.length-1]=0;
    System.out.println(Arrays.toString(arr));
  }

(2) 입력 요소에 따라 배열에서 해당 요소를 삭제합니다

< br/>

public static void delete(int[] arr,int ele){
    int index=-1;
    for(int i=0;i<arr.length;i++){
      if(arr[i]==ele){
        index=i;
      }
    }
    for(int i=index;i<arr.length-1;i++){
      arr[i]=arr[i+1];
    }
    arr[arr.length-1]=0;
    System.out.println(Arrays.toString(arr));
  }

여기API의 일반적인 배열 작업

Java에서는 java 제외.lang 클래스 및 인터페이스를 직접 사용할 수 있지만 다른 패키지의 클래스나 인터페이스를 사용하려면 선행 패키지가 필요합니다.

java.util.Arrays 클래스: 이 클래스에는 배열을 작동하는 데 사용되는 함수(예: 정렬 및 다양한 검색 방법).

정적 메소드로, 클래스 이름과 메소드 이름, 여기서는 int 배열을 예로 들어 보겠습니다.

1、对数组进行快速排序

Arrays.sort(int[] arr);对传入的数组默认进行升序排序

2、返回指定数组内容的字符串表现形式。

Arrays.toString(int[] arr);

3、使用二分法搜索制定数组中的某个元素的下标

Arrays.binarySearch(int[] arr);

4、将将指定的 int 值分配给指定 int 型数组的每个元素。

Arrays.fill(int[] arr,int val);

5、复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。

Arrays.copyOf(int[] arr,int newLength);它的返回值是一个数组

6、将指定数组的指定范围复制到一个新数组。 包含起始位置但不包含结束位置。

Arrays.copyOfRange(int[] arr,int from,int to);它的返回值是一个数组

其他数组知识：

1、命令行参数：可以在执行java命令时为main方法传入参数值。

用法：运行java命令时传入命令行参数: java 类名 "值1" "值2"...

public static void main(String[] args){},我们可以看到main方法是一个有参的方法，参数是一个字符串数组，在命令行为main方法传值时，传入的值都保存在args字符数组里。

注意：多个参数值之间用空格分割。参数的值将会保存到字符串数组传入main方法，下标从零开始。

在获取命令行参数时需要注意下标不能越界，最大下标应该为参数的个数-1

public static void main(String[] args){
     for(int i=0;i<args.length;i++){
         System.out.println(args[i]);
     }
 }

2、可变参数

可变参数是java1.5之后的新特性，可以代表零到多个相同数据类型的变量，是为了解决因参数个数的变化而导致过多的方法重载问题。

注意：

1、可变参数只能用于形式参数（方法定义时），可以把可变参数当作数组来处理。

2、一个方法在最多只能有一个可变参数，可变参数必须作为最后一个参数。

3、调用带可变参数的方法时，数据类型必须与可变参数的类型对应。

public class Test1 {
  public static void main(String[] args){
    double sum=add(4,2.1,3.4,1.2);
    System.out.println(sum);
  }
  public static double add(int a,double...b){
    double sum=a;
    for(int i=0;i<b.length;i++){
      sum+=b[i];
    }
    return sum;
  }
}

例题：

合并数组操作：现有如下一个数组： int oldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5} 要求将以上数组中值为0的项去掉，将不为0的值存入一个新的数组，生成的新数组为： int newArr [] ={1,3,4,5,6,6,5,4,7,6,7,5}

思路： 确定出不为0的个数，这样可以开辟新数组；从旧的数组之中，取出内容，并将其赋给新开辟的数组。

public class Test1 {
  public static void main(String[] args){
    int oldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5};
    int[] arr=mergeArrays(oldArr);
    System.out.println(Arrays.toString(arr));
  }
  public static int[] mergeArrays(int[] oldArr){
    int count=0;
    for(int i=0;i<oldArr.length;i++){
      if(oldArr[i]!=0){
        count++;
      }
    }
    int[] newArr=new int[count];
    int index=0;
    for(int i=0;i<oldArr.length;i++){
      if(oldArr[i]!=0){
        newArr[index]=oldArr[i];
        index++;
      }
    }
    return newArr;
  }
}

2、使用二分法查找有序数组中元素。找到返回索引，不存在输出-1。使用递归实现

public class Test1 {
  public static void main(String[] args){
    int[] arr={1,2,3,4,5,6,7,8};
    int index=binarySearch(arr,6,0,arr.length-1);
    System.out.println(index);
  }
  public static int binarySearch(int[] arr,int ele,int left,int right){
    int mid=(left+right)/2;
    if(arr[mid]==ele){
      return mid;
    }else if(arr[mid]<ele){
      return binarySearch(arr,ele,mid+1,right);
    }else if(arr[mid]>ele){
      return binarySearch(arr,ele,left,mid-1);
    }
    return -1;
  }
}

위 내용은 Java(컬렉션) 기반 배열에 대한 일반적인 작업 요약의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!