当前位置:主页 > 查看内容

数组的定义与使用(Java)学习总结

发布时间:2021-06-24 00:00| 位朋友查看

简介:每天努力一点点 -Make a little progress every day 文章目录 前言 1、数组基本用法 1.1 什么是数组 1.2 创建数组 1.3 数组的使用 2、数组做为方法的参数 返回值 3、数组练习 前言 随着时代的发展编程语言也在进步Java语言更是成为当今时代潮流本文简述了阿……

每天努力一点点
-Make a little progress every day

前言

随着时代的发展编程语言也在进步,Java语言更是成为当今时代潮流,本文简述了阿杰对Java语言的初步认识,并记录阿杰初次进行Java入门学习的部分重要基础内容;

1、数组基本用法

1.1 什么是数组

数组本质上是能让我梦批量创建相同类型的变量;
数组存在于堆中,对数组来说栈内存的是与数组地址相对的唯一值,通过hash()该值可以获得与之对应的堆中的唯一地址;

1.2 创建数组

基本语法格式
1、动态初始化:
数据类型[ ]数组名称 = new 数据类型[ ] {初始变量值};
例:
int [ ] array =new int[ ]{1,2,3}
或int [ ] array = new int[ 5] \数组存在于堆中,堆中都有初始值)

2、静态初始化:
数据类型[ ] 数组名称 = {初始化数据};
例:
int[ ] array = {1,2,3,4}

3、二维数组:
数据类型 [ ] [ ] 数组名称 = new 数组类型 [行数] [列数]{初始化数据};

1.3 数组的使用

数组的打印

//有序打印:
for(int i = 0; i < array length; i++){
	System.out.println(array[i]+" ");
}
//无序打印
for(int i: array1){
System.out.println(a + " ");
}
//例:输出数组的长度
int [ ] array = new int{1, 2 ,3 4};
System.out.println("length"+arr.length);

//例将数组转为字符串
string ret = arrays to string(array);
System.out.println(ret);

注意事项:
1、使用 array.length可以获取长度;
2、数组下表是从零开始;
3、下标操作不能超出有效范围[0,length-1] ;
4、array [ ] = array [5];其中默认初始值为零;
下标越界异常:

Java.lang,ArrayIndexoutofBondsExpection:

2、数组做为方法的参数 返回值

  • 数组作为方法的参数要注意参数在方法中开辟栈是否被赋值;
  • null在Java中表示空引用;
int [ ] array = null;
System.out.println(array(0));

//执行结果
Exception in thread "java.lang.NullPointerException at Text.main(Text.java:6)"

null 表示一个无效的内存位置;

  • 为了不破坏原数组需要在方法内创建一个新数组;

3、数组练习

1. 数组转字符:

  package com.company;
import java.util.*;
public class Main {
    public static void main(String[] args){
        int [] array = new int[]{1,2,3,4,5};
        swap(array);
    }
    //数组转字符串
    public static void swap(int[] array){
        String ret = Arrays.toString(array);
        System.out.println(ret);
    }
}

2. 数组拷贝:

   package com.company;
import java.util.*;
public class Main {
    public static void main(String[] args) {
        int [] array = new int[]{1,2,3,4,5};
        copy(array);
    }
    //拷贝数组
    public static void copy(int[] array){
        int[] ret = new int[5];
        for(int i=0; i < array.length; i++){
            ret[i] = array[i];
        }
        String ret1 = Arrays.toString(ret);
        System.out.println(ret1);
    }
}

3. 找数组中最大元素:
(小元素同理)

      package com.company;
import java.util.*;
public class Main {
    public static void main(String[] args) {
        int [] array = new int[]{1,2,3,4,5};
        find(array);
    }
//找出数组中最大的元素
    public static void find(int[] arr){
        int m = arr[0];
        for(int i = 1; i < arr.length; i++){
            if(arr[i] > m){
            m = arr[i];
            }
            if(i == arr.length -1){
            System.out.println(m);
            }
        }
    }
}

4. 求数组平均值:

   package com.company;
import java.util.*;
public class Main {
    public static void main(String[] args) {
        int [] array = new int[]{1,2,3,4,5};
        ave(array);
    }
    //求平局值
    public static void ave(int[] arr){
        int sum = 0;
        for(int i = 0; i < arr.length; i++){
            sum += arr[i];
            if(i == arr.length-1){
                System.out.println(sum/arr.length);
            }

        }
    }
}

5. 查找指定元素:

  • 顺序查找
    package com.company;
import java.util.*;
public class Main {
    public static void main(String[] args) {
        int [] array = new int[]{1,2,3,4,5};
        find(array,3);
    }
    //顺序查找
      public static void find(int[] arr,int n){
        for(int i = 0; i < arr.length; i++){
            if(arr[i] == n){
                System.out.println(i);
            }
            if(i == arr.length && arr[i] != n){
            System.out.println("没有扎到");
            }
        }
      }
}
  • 二分查找(针对有序数组)
     package com.company;
import java.util.*;
public class Main {
    public static void main(String[] args) {
        int [] array = new int[]{1,2,3,4,5};
        find1(array,3);
    }
    //二分查找(针对有序数组)
    public static void find1(int[] arr1 , int n){
        int right = arr1.length-1;
        int left = 0;
        while(left < right){
            int mid = (left + right)/2;
            if(n < arr1[mid]){
                right = mid - 1;
            } else if(n > arr1[mid]){
                left = arr1.length-1;
            }else{
                System.out.println(mid);
                break;
            }
        }
    }
}

6. 检查数组的有序性:

      package com.company;
import java.util.*;
public class Main {
    public static void main(String[] args) {
        int [] array = new int[]{1,10,3,4,5,6,7,8,9};
        check(array);
    }
      //检查数组的有序性
    public static void check(int [] arr){
        int count = 0;
        for(int i = 0; i < arr.length-1; i++){
            if(arr[i] > arr[i+1]){
            System.out.println("无序");
            count = count + 1;
            break;
            }
        }
        if(count == 0) { 
            System.out.println("有序");
        }
    }
}

7. 冒泡排序:

       package com.company;
import java.util.*;
public class Main {
    public static void main(String[] args) {
        int [] array = new int[]{1,10,3,4,5,6,7,8,9};
       abc(array);
    }
    //冒泡排序
    public static void abc(int[] arr){
      for (int i =0; i < arr.length;i++){
          boolean aaa = false;
          for(int j = i+1; j < arr.length; j++){
              if(arr[i] > arr[j]){
                  int c = arr[i];
                  arr[i] = arr[j];
                  arr[j] = c;
                  aaa=true;
              }
              if(aaa == false){
                  break;
              }
          }
          System.out.println(arr[i]);
      }
    }
}

冒泡排序性能较低,Java中有更高级的算法“ Arrays.sort( ) ”
(面试可能问到 优化冒泡程序)
8. 数组逆序:

     package com.company;
import java.util.*;
public class Main {
    public static void main(String[] args) {
        int [] array = new int[]{1,2,3,4,5,6,7,8,9};
        reverse (array);
    }
    //数组逆序
    public static void reverse(int[] arr){
        int i = 0;
        int j = arr.length-1;
        while(i < arr.length-1){
            int a = arr[i];
            arr[i] = arr[j];
            arr[j] = a;
            i++;
            j--;
            if(i == (arr.length-1)/2){//到中间两边互换下标完成
                break;
            }
        }for(int k = 0; k < arr.length; k++){
        System.out.println(arr[k]);
       }
    }
}

9. 把数组中偶数放前奇数放后:

     package com.company;
import java.util.*;
public class Main {
    public static void main(String[] args) {
        int [] array = new int[]{1,2,3,4,5,6,7,8,9};
        swap (array);
    }
    //将数组中偶数放在前奇数放在后
    public static void swap(int[] arr){
        int i = 0;
        int j = arr.length-1;
        while(i<j){
        while(arr[i] % 2 == 0){
            i++;
        }//找到靠左边的奇数
        while(i<j && arr[j] % 2 != 0){
            j--;
        }//找到靠右边的偶数(要加 i<j不然会多交换)
            int c = arr[i];
            arr[i] = arr[j];
            arr[j] =c;
        }
        System.out.println(Arrays.toString(arr));
    }
}

加油!!!

;原文链接:https://blog.csdn.net/m0_56774467/article/details/115498741
本站部分内容转载于网络,版权归原作者所有,转载之目的在于传播更多优秀技术内容,如有侵权请联系QQ/微信:153890879删除,谢谢!

推荐图文


随机推荐