当前位置:   article > 正文

Java知识点整理——数组_java数组知识点总结

java数组知识点总结

一、数组

1. 概述:

     数组是相同数据类型的多个数据的容器

     这些元素按线性顺序排列。所谓线性顺序是指除第一个元素外,每一个元素都有唯一的前驱元素;除最后一个 元素外,每一个元素都有唯一的后继元素。(“简单理解就是:一个跟一个按照顺序排列”)。

2. 创建格式:

     格式 1. 数据类型[] 数组名称 = new 数据类型[数组长度];

     格式 2. 数据类型[] 数组名称 = {数组内容 1,数组内容 2,数组内容 3...数组内容 n};

     格式 3. 数据类型[] 数组名;

           格式 3 属于只创建了数组引用名, 并未在内存创建数组空间。

     格式 4. 数据类型[] 数组名称 = new 数据类型[]{内容 1,内容 2,内容 3...内容 n};

3. 下标:

     可以理解为数组中内容的数字序号,从 0 开始 ,对于长度为 n 的数组,下标的范围是 0~n-1。

     可以通过下标的方式访问数组中的每一个元素。

     例如: 创建 int 类型数组 arr , 给数组 arr 的 5 下标赋值数据 , 然后打印

  1. int[] arr = new int[10];
  2. arr[5] = 123;
  3. System.out.println(arr[5]);

4. 数组长度获取:

     数组名称.length

5. 注意:

     使用数组不当, 会出现如下问题:

        数组未赋值: 空指针异常

        超出长度的下标操作: 数组越界异常

   注意:数组的长度在创建时就固定了。

  1. package com.kaikeba.demo1;
  2. public class Demo2 {
  3. public static void main(String[] args) {
  4. //常见问题:
  5. // 1. 数组下标越界问题:
  6. //int[] nums = {10,11,12,13,14};
  7. //System.out.println(nums[5]);
  8. // 2. 空指针问题
  9. int[] nums = null;
  10. System.out.println(nums[1]);
  11. }
  12. }

补充:找出无序数组中的最大/最小值。

  1. package com.kaikeba.demo1;
  2. public class Demo3 {
  3. //寻找数组中的最大值 | 最小值
  4. public static void main(String[] args) {
  5. int[] nums = {10,30,40,33,22,20,11,0};
  6. //1. 创建一个变量, 用于存储遍历数组时发现的最大值
  7. int n = nums[0];
  8. //2. 循环取出数组中的每一个内容, 从1开始
  9. for(int i=1;i<nums.length;i++) {
  10. //将数组中的每一个内容与n比较, 如果比n大, 则将n的值赋值为这个内容。
  11. n = n<nums[i]?n:nums[i];
  12. }
  13. System.out.println(n);
  14. }
  15. }

 

二、数组常用算法

1. 冒泡排序:

原理:

  • 比较相邻的元素。如果第一个比第二个大,就交换他们两个。
  • 对每一对相邻元素做同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的 数。
  • 针对所有的元素重复以上的步骤,除了最后一个。
  • 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。

名字由来:

     是因为最小(或最大)的元素会经由交换慢慢“浮”到数列的顶端(降序或升序),就如同水中的气泡最终会上浮到顶端一样,故名“冒泡排序”。

  1. 升序排列的口诀:
  2. N个数字来排队
  3. 两两相比小靠前,
  4. 外层 循环length-1
  5. 内层循环length-i-1
  6. 降序排序的口诀:
  7. N个数字来排队
  8. 两两相比大靠前,
  9. 外层 循环length-1
  10. 内层循环length-i-1

冒泡排序代码示例:

  1. package com.kaikeba.demo1;
  2. public class Demo4 {
  3. /**
  4. * 冒泡排序
  5. * @param args
  6. */
  7. public static void main(String[] args) {
  8. int[] nums = {20,15,18,13,30,60};
  9. int temp;
  10. //外层循环控制的是, 比较的轮数。
  11. //外层循环次数: length-1
  12. for(int i=0;i<nums.length-1;i++) {
  13. //内层循环控制的是,每轮比较的次数
  14. //第i轮(i从0开始计算), 比较次数为:length-i-1
  15. for(int j=0;j<nums.length-i-1;j++) {
  16. if(nums[j]>nums[j+1]) {
  17. //两两相比, 满足移动条件
  18. temp = nums[j];
  19. nums[j] = nums[j+1];
  20. nums[j+1] = temp;
  21. }
  22. }
  23. }
  24. //排序已经完成。 下面是遍历打印查看的过程
  25. for(int i=0;i<nums.length;i++) {
  26. System.out.println(nums[i]);
  27. }
  28. }
  29. }

2. 二分查找(折半查找):

概述:

     二分查找也称折半查找(Binary Search),它是一种效率较高的查找方法。但是,二分查找要求数组数据必须采用顺序存储结构有序排列

原理:

     首先,假设数组中元素是按升序排列,将数组中间位置的数据与查找数据比较,如果两者相等,则查找成功;否则利用 中间位置记录将数组分成前、后两个子数组,如果中间位置数据大于查找数据,则进一步查找前子数组,否则进一步查 找后子数组。

     重复以上过程,直到找到满足条件的数据,则表示查找成功, 直到子数组不存在为止,表示查找不成功。

二分查找代码示例:

  1. package com.kaikeba.demo1;
  2. public class Demo5 {
  3. /**
  4. * 二分查找(折半查找)
  5. */
  6. public static void main(String[] args) {
  7. int[] nums = {10,20,30,40,50,60,70,80,90};
  8. //要查找的数据
  9. int num = 20;
  10. //关键的三个变量:
  11. //1. 最小范围下标
  12. int minIndex = 0;
  13. //2. 最大范围下标
  14. int maxIndex = nums.length-1;
  15. //3. 中间数据下标
  16. int centerIndex = (minIndex+maxIndex)/2;
  17. while(true) {
  18. System.out.println("循环了一次");
  19. if(nums[centerIndex]>num) {
  20. //中间数据较大
  21. maxIndex = centerIndex-1;
  22. }else if(nums[centerIndex]<num) {
  23. //中间数据较小
  24. minIndex = centerIndex+1;
  25. }else {
  26. //找到了数据 数据位置:centerIndex
  27. break;
  28. }
  29. if(minIndex > maxIndex) {
  30. centerIndex = -1;
  31. break;
  32. }
  33. //当边界发生变化, 需要更新中间下标
  34. centerIndex = (minIndex+maxIndex)/2;
  35. }
  36. System.out.println("位置:"+centerIndex);
  37. }
  38. }

 

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/代码探险家/article/detail/782755
推荐阅读
相关标签
  

闽ICP备14008679号