Zusammenfassung gängiger Operationen für Arrays basierend auf Java (Sammlung)

Der folgende Editor bietet Ihnen eine Zusammenfassung der gängigen Operationen von Arrays basierend auf Java (ein Artikel, den Sie unbedingt lesen müssen). Der Herausgeber findet es ziemlich gut, deshalb teile ich es jetzt mit Ihnen und gebe es als Referenz. Folgen wir dem Editor und werfen wir einen Blick darauf

Häufig verwendete Operationen für Arrays

1 Finden Sie den Wert in einem Array Maximalwert, Minimalwert

Idee: Angenommen, das Element mit dem Index 0 ist der Maximalwert, durchlaufen Vergleichen Sie das Array wiederum mit max. Wenn es ein Element gibt, das größer als dieser Wert ist, weisen Sie diesen Wert max zu. Der Mindestwert ist auch

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. Finden Sie heraus, ob ein Element im Array vorhanden ist

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 ), Verwenden Sie die Methode Binäre Suche, um herauszufinden, ob ein Element in einem Array vorhanden ist

Voraussetzung: Das zu durchsuchende Array muss geordnet (größengeordnet) sein

Prinzip: Vergleichen Sie das zu findende Element mit dem mittleren Indexelement im Array. Wenn es größer als das mittlere Element ist, suchen Sie nach rechts.

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. Sortieren Sie das Array

(1), Blasensortierung

Prinzip: Vergleichen Sie benachbarte Elemente, kleine bewegen sich vorwärts, große bewegen sich rückwärts und der Maximalwert erscheint am größten Index

Analyse : Zum ersten Mal vergleichen, die größeren werden später angezeigt und der Maximalwert wird am größten Index eingestuft

Zum zweiten Mal vergleichen, da der Maximalwert ermittelt wurde, sind nur die ersten n erforderlich Zum Vergleich reicht -1 Element aus, ermitteln Sie den zweitgrößten Wert und ordnen Sie ihn dem zweitgrößten Index zu

Bestimmen Sie den drittgrößten Wert, wiederum den viertgrößten Wert...

Fazit: N Zahlen stehen in der Warteschlange und die kleineren stehen vorne. Die äußere Schleife ist n-1 und die innere Schleife ist 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), Sortierung auswählen

Prinzip: Beginnen Sie mit dem Index 0 und vergleichen Sie ihn nacheinander mit den folgenden Elementen. Wenn das letztere Element kleiner als das Element mit dem Index 0 ist, transponieren Sie. Vergleichen Sie das neue Element mit Index 0 mit dem folgenden Element. Nach der ersten Vervollständigung erscheint der Mindestwert bei Index 0

Beispiel: ｛10, 3, 8, 1, 6｝

Die erste Vergleichsrunde, beginnend mit dem Indexelement 0, in der Reihenfolge Um mit den folgenden Elementen zu vergleichen, vergleichen Sie zuerst 10 und 3, 10<3, tauschen Sie die Positionen aus, das Element mit dem Index 0 wird zu 3, {3, 10, 8, 1, 6}, dann vergleichen Sie 3 und 8, 3< 8, keine Transposition; 3 und 1 vergleichen, 3>1, transponieren

｛1, 10, 8, 3, 6}, dann 1 und 6 vergleichen, 1<6, keine Position ändern. Die erste Runde endet mit {1, 10, 8, 3, 6}

In der zweiten Vergleichsrunde hat die vorherige Runde festgestellt, dass das Element mit dem Index 0 der Mindestwert ist, mit dem diese Vergleichsrunde beginnt Index 1, zuerst 10 und 8 vergleichen, transponieren {1, 8, 10, 3, 6}; 8 und 3 vergleichen, {1, 3, 10, 8, 6} vergleichen, 3 und 6 vergleichen, nicht transponieren. Am Ende der zweiten Runde wird festgestellt, dass das vorletzte Element den Index 1 hat.

......

Insgesamt werden Runden der Länge 1 verglichen.

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. Löschen Sie das -Element im Array

(1) Löschen Sie Elemente entsprechend den Indizes (füllen Sie 0 für Lücken ein)

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) Löschen Sie die entsprechenden Elemente im Array entsprechend den Eingabeelementen

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));
  }

unten Stellen Sie einige gängige Array-Operationen in der API

in Java vor, mit Ausnahme der Klassen unter dem Paket java.lang und Mit Ausnahme der Schnittstelle , die direkt verwendet werden kann, erfordern Klassen oder Schnittstellen unter anderen Paketen bei Verwendung ein führendes Paket.

java.util.Arrays-Klasse: Diese Klasse enthält verschiedene Methoden zum Bearbeiten von Arrays (z. B. Sortieren und Suchen).

Dies sind alles statische Methoden, die direkt nach Klassennamen und Methodennamen verwendet werden können. Hier nehmen wir ein int-Array als Beispiel

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;
  }
}

Das obige ist der detaillierte Inhalt vonZusammenfassung gängiger Operationen für Arrays basierend auf Java (Sammlung). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!