Résumé des opérations courantes sur les tableaux basés sur Java (collection)

L'éditeur suivant vous apportera un résumé des opérations courantes des tableaux basés sur Java (un article à lire absolument). L'éditeur pense que c'est plutôt bien, alors je vais le partager avec vous maintenant et le donner comme référence. Suivons l'éditeur et jetons-y un coup d'œil

Opérations couramment utilisées sur les tableaux

1. dans un tableau Valeur maximale, valeur minimale

Idée : Supposons que l'élément avec l'indice 0 est la valeur maximale, traverse le tableau , comparez-le à max à son tour. S'il y a un élément plus grand que ce max, attribuez cette valeur à max. La valeur minimale est également

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. Recherchez si un élément existe dans le tableau

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). ), Utilisez la méthode recherche binaire pour savoir si un élément existe dans un tableau

Prémisse : Le tableau à rechercher doit être ordonné (ordre par taille)

Principe : Comparez l'élément à trouver avec l'élément d'indice du milieu du tableau. S'il est supérieur à l'élément du milieu, recherchez vers la droite ; s'il est plus petit que l'élément du milieu, recherchez vers la gauche.

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. Trier le tableau

(1), Tri à bulles

Principe : Comparez les éléments adjacents, les petits avancent, les grands reculent et la valeur maximale apparaît au plus grand index

Analyse : Comparez pour la première fois, les plus grandes apparaîtront plus tard, et la valeur maximale sera classée au plus grand indice

Comparez pour la deuxième fois, car la valeur maximale a été déterminée, seuls les n premiers ont besoin pour être comparé -1 élément suffit, déterminez la deuxième plus grande valeur et classez-la au deuxième plus grand indice

Déterminez la troisième plus grande valeur, la quatrième plus grande valeur tour à tour...

Conclusion : N nombres sont en file d'attente, et les plus petits sont à l'avant. La boucle extérieure est n-1, et la boucle intérieure est 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), Sélectionner le tri

Principe : à partir de l'indice 0, comparez avec les éléments suivants dans l'ordre. Si ce dernier élément est plus petit que l'élément d'indice 0, transposez. Comparez le nouvel élément d'index 0 à l'élément suivant. Après la première complétion, la valeur minimale apparaît à l'index 0

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

Le premier tour de comparaison, à partir de l'élément d'indice 0, dans l'ordre Pour comparer avec les éléments suivants, comparez d'abord 10 et 3, 10<3, échangez les positions, l'élément avec l'indice 0 devient 3, {3, 10, 8, 1, 6} puis comparez 3 et 8, 3< ; 8, pas de transposition ; comparer 3 et 1, 3>1, transposer

｛1, 10, 8, 3, 6}, puis comparer 1 et 6, 1<6, pas de changement de position. Le premier tour se termine, {1, 10, 8, 3, 6}

Le deuxième tour de comparaison, le tour précédent a déterminé que l'élément d'indice 0 est la valeur minimale, ce tour de comparaison commence à partir de indice 1 , comparez d'abord 10 et 8, transposez {1, 8, 10, 3, 6} ; comparez 8 et 3, transposez {1, 3, 10, 8, 6}, comparez 3 et 6, ne transposez pas. A la fin du deuxième tour, il est déterminé que l'avant-dernier élément est à l'indice 1.

.....

Un total de tours de longueur 1 sont comparés.

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 Supprimez l'élément dans le tableau.

(1) Supprimer les éléments en fonction des indices (remplissez 0 pour les lacunes)

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) Supprimer les éléments correspondants dans le tableau en fonction des éléments d'entrée

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

ci-dessous Présentez quelques opérations de tableau courantes dans API

en java, à l'exception des classes sous le package java.

lang et À l'exception de l'interface qui peut être utilisée directement, les classes ou interfaces sous d'autres packages nécessitent un package principal lorsqu'elles sont utilisées.

Classe java.util.Arrays : Cette classe contient diverses méthodes de manipulation des tableaux (telles que le tri et la

recherche).

Ce sont toutes des méthodes

statiques, qui peuvent être utilisées directement par nom de classe et nom de méthode. Ici, nous prenons le tableau int comme exemple.

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!