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)、用二分查找法查找数组中是否存在某个元素

前提:待查找的数组必须是有序的(大小有序)

原理:将待查找的元素与数组中中间下标的元素进行比较,如果大于中间元素,去右边查找,小于中间元素,去左边查找。

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)、冒泡排序

原理:相邻元素进行比较,小的往前赶,大的往后冒,最大值出现的最大索引处

分析:第一次进行比较,大的往后冒,会把最大值排在最大索引处

第二次进行比较,因为最大值已经确定了,只需要比较前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位置。

........

共比较length-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)

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)根据输入的元素删除数组中对应的元素

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基础之数组常用操作总结(必看篇)就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持我们。

(0)

相关推荐

  • java 两个数组合并的几种方法

    本文介绍了java 两个数组合并的几种方法,分享给大家,也给自己留个笔记 需求:两个字符串合并(如果想去重复,参考下一篇--数组去重复及记录重复个数) //方法一 Arrays类 String[] a = {"A","B","C"}; String[] b = {"D","E"}; // List<String> list = Arrays.asList(a); --OK // List<

  • java整数与byte数组的转换实现代码

    java整数与byte数组的转换实现代码            这里对java中整数与byte数组的转换进行了实现,平时的项目中很少用的到,但是特定需求的时候还是需要的,这里就记录下,亲测可用, 实现代码: public class NumberUtil { /** * int整数转换为4字节的byte数组 * * @param i * 整数 * @return byte数组 */ public static byte[] intToByte4(int i) { byte[] targets =

  • java实现向有序数组中插入一个元素实例

    整理文档,搜刮出一个java实现向有序数组中插入一个元素,稍微整理精简一下做下分享 package cn.jbit.array; import java.util.*; public class Insert { public static void main(String[] args) { //字符排序 char[] chars = new char[9]; chars[0] = 'a'; chars[1] = 'c'; chars[2] = 'u'; chars[3] = 'b'; cha

  • Java编程实现统计数组中各元素出现次数的方法

    本文实例讲述了Java编程实现统计数组中各元素出现次数的方法.分享给大家供大家参考,具体如下: package javatest; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Map.Entry; import java.util.Set; public class NumOfEle { public static void main(String[] ar

  • 关于Java数组查询的相关问题及实例 原创

    在做数组查询的过程中,我们有时候会遇到一些问题,下面就跟随作者一起解答这些问题. Arrays 类的 binarySearch() 方法,可使用二分搜索法来搜寻指定数组,以获得指定对象.该方法返回要搜索元素的索引值. binarySearch()方法提供了多种重载形式,用于满足各种类型数组的查找需要. binarySearch()方法有两种参数类型. (1)binarySearch(Object[] a.Object key) 其中a 代表要所搜的数组,key 表示要搜索的值.如果key 包含在

  • 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.leng

  • python常用知识梳理(必看篇)

    接触python已有一段时间了,下面针对python基础知识的使用做一完整梳理: 1)避免'\n'等特殊字符的两种方式: a)利用转义字符'\' b)利用原始字符'r' print r'c:\now' 2)单行注释,使用一个#,如: #hello Python 多行注释,使用三个单引号(或三个双引号),如: '''hello python hello world''' 或 """hello python hello world""" 另外跨越多行

  • Java的基本数据类型和运算方法(必看篇)

    编码 ASCII--0~127 65-A 97-a 西欧码表---ISO-8859-1---0-255---1个字节 gb2312----0-65535---gbk---2个字节 Unicode编码体系---utf-8---3个字节 中 f bit位 Byte字节 1Byte = 8bit 1KB=1024B MB GB TB PB---计算机中存储单位 常量 整数常量---所有的整数 3,99,107 小数常量---所有的小数 3.5 100.9 字符常量---用单引号将一个字母.数字.符号标

  • java同步锁的正确使用方法(必看篇)

    同步锁分类 对象锁(this) 类锁(类的字节码文件对象即类名.class) 字符串锁(比较特别) 应用场景 在多线程下对共享资源的安全操作. 需求:启动5个线程对共享资源total进行安全操作. 同步锁在多线程单例模式下的使用 以上三类同步锁都可以. package cn.myThread; public class MyThread implements Runnable { private static int total = 10; @Override public void run()

  • js字符串操作总结(必看篇)

    字符方法 <!DOCTYPE html> <html lang="en"> <head> <meta charset="utf-8"> <title>字符方法</title> </head> <body> <script type="text/javascript"> /* charAt方法和charCodeAt方法都接收一个参数,基于0的

  • jQuery 常用代码集锦(必看篇)

    1. 选择或者不选页面上全部复选框 var tog = false; // or true if they are checked on load $('a').click(function() { $("input[type=checkbox]").attr("checked",!tog); tog = !tog; }); 2. 取得鼠标的X和Y坐标 $(document).mousemove(function(e){ $(document).ready(func

  • Eclipse常用快捷键总结(必看篇)

    Alt+/                                内容辅助 最常用的快捷键,省去了自己一个字一个字敲代码的时间 Ctrl+Shift+F                        格式化文档 Ctrl+Shift+O                    批量导入包 Ctrl+t                                 打开类型树 Ctrl+鼠标左键 / F3              打开申明 查看代码的时候经常会用到 Alt+左箭头    

  • 详谈PHP基础与JS操作的区别(必看篇)

    嵌入页面方式 JS嵌入方式:<script></script> PHP嵌入方式:<?php ?>(常用) 输出语法 Javascript输出 1.alert("警告的内容") 2.prompt("提示的内容") 3.document.write()(页面输出内容) PHP输出 1.echo(常用)//可同时输出多个字符串 eg:echo $a,"hello"; 2.print //只能输出一个字符串 eg:pr

  • Java基础之数组模拟循环队列

    一.队列简介 队列是一个有序列表,遵循"先入先出"的原则,即先存入队列的数据要先取出,后存入的数据后取出. 队列有两种存储表示,顺序表示和链式表示.顺序表示可以用数组来实现. 二.数组模拟队列 用数组模拟队列时,设两个值front=0,rear=0.front表示队列首部第一个数据所在位置,rear表示尾部最后一个数据的下一个位置. 将数据插入数组队列时(入队),从尾部进行插入,即array[rear] = value,同时rear后移,rear++.取出数据时(出队),从头部取出数据

  • Java基础之数组详解

    前言 我们了解数组这个概念之前,我们先思考下面几个问题. 如果我们需要两个数据,那么直接创建两个变量即可 int a; int b; 如果需要五个数据,那么可以创建五个变量 int a; int b; int c; int d; int f; 但如果我们需要100个甚至是1万个数据,那么我们创一万个变量?显然这是不现实的.这个时候就需要我们的数组来起作用!帮我们"批量"创建变量. 由上可以得出:数组的本质就是让我们能"批量"创建相同类型的变量! 一.数组的概念 数组

随机推荐