import java.util.Arrays;

 public class HelloArrayOp {

     public static void main(String[] args) {
// TODO Auto-generated method stub System.out.println("第131页:数组的基本操作:"
+ "\n1.遍历数组"
+ "\n2.填充替换数组元素"
+ "\n3.对数组进行排序"
+ "\n4.复制数组"
+ "\n5.范例一:对比一维、二维数组所占内存"
+ "\n6.范例二:使用直接插入排序法排序"
+ "\n7.范例三:使用冒泡排序法排序"
+ "\n8.范例四:输出九宫格"
+"\n9.实战:输出二维数组中所有元素之和");
// No1:遍历数组
System.out.println("\n 【No1:遍历数组】");
int day[] = new int[] { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
for (int i = 1; i <= 12; i++) {
System.out.print(i + " 月有 " + day[i - 1] + " 天" + "\t\t");
if (i % 3 == 0)
System.out.println();
}
/*
* oreach的语句格式: for(元素类型t 元素变量x : 遍历对象obj){ 引用了x的java语句; }
*/
int arr2[][] = { { 1, 2, 3 }, { 7, 8, 9 } };
System.out.println("遍历二维数组:");
for (int x[] : arr2) {
for (int m : x) {
System.out.print(m + " \t");
}
} // No2:填充替换数组元素: fill(int[] a,int value)
// fill(int[] a,int fromIndex, int toIndex(包括), int value(不包括))
System.out.println("\n\n 【No2:填充替换数组元素】 ");
int arr3[] = new int[5];
Arrays.fill(arr3, 8);
System.out.println("填充后所有的值都相同:");
for (int y : arr3) {
System.out.print(y + "\t");
}
System.out.println("\n给指定范围填充值");
Arrays.fill(arr3, 1, 3, 6);
for (int y : arr3) {
System.out.print(y + "\t");
} // No3:对数组进行排序 sort()
System.out.println("\n\n 【No3:对数组进行排序】");
int arrS[] = new int[] { 8, 10, 4, 1, 5, 6, 3 };
System.out.println("原数组:");
for (int s : arrS) {
System.out.print(s + "\t");
}
Arrays.sort(arrS);
System.out.println("\n排序后数组:");
for (int s : arrS) {
System.out.print(s + "\t");
} // No4:复制数组 copyOf() copyOfRange()
System.out.println("\n\n 【No4:复制数组】");
int arrC1[] = new int[] { 1, 2, 3, 4, 5, 6 };
int arrNew[] = Arrays.copyOf(arrC1, 3);
int arrNew2[] = Arrays.copyOfRange(arrC1, 3, 5);
System.out.println("复制后的数组arrNew是:");
for (int c1 : arrNew) {
System.out.print(c1 + "\t");
}
System.out.println("\n复制后的数组arrNew2是:");
for (int c1 : arrNew2) {
System.out.print(c1 + "\t");
} // No5:范例一:对比一维、二维数组所占内存 System.out.println("\n\n 【No5:范例一:对比一维、二维数组所占内存】");
int num1 = 1024 * 1024 * 2;
int arrNum[] = new int[num1];
for (int i = 0; i < arrNum.length; i++) {
arrNum[i] = i;
}
// 获得占用内存总数,并将单位转换为MB
long memory1 = Runtime.getRuntime().totalMemory() / 1024 / 1024;
System.out.println("用一维数组占用内存总量为" + memory1 + "M"); int num2 = 1024 * 1024;
int arrNum2[][] = new int[num2][2];
for (int j = 0; j < arrNum2.length; j++) {
arrNum2[j][0] = j;
arrNum2[j][1] = j;
}
// 获得占用内存总数,并将单位转换为MB
long memory2 = Runtime.getRuntime().totalMemory() / 1024 / 1024;
System.out.println("用二维数组占用内存总量为" + memory2 + "M");
/* 额,显示是占用内存相同。待考证。。。 */ // No6:范例二:使用直接插入排序法排序 逻辑:将要排序的值逐个插入到其所适合的位置,其后的元素都向后移一个位置;
int arrSort2[] = new int[] { 2, 3, 1, 5, 6, 7, 9 };
System.out.println("\n【No6:范例二:使用直接插入排序法排序】\n 排序前输出:");
for (int k : arrSort2) {
System.out.print(k + "\t");
}
int exchange, n;
for (int m = 1; m < arrSort2.length; m++) {
exchange = arrSort2[m];
for (n = m - 1; n >= 0 && arrSort2[n] > exchange; n--) { // 把大于号改成小于号就变成了倒序哟~~
arrSort2[n + 1] = arrSort2[n];
}
arrSort2[n + 1] = exchange;
}
System.out.println(" \n 排序后输出:");
for (int k : arrSort2) {
System.out.print(k + "\t");
} // No7.范例三:使用冒泡排序法排序 特点:排序稳定,效率不高
// 逻辑:对比相邻的两个值如果满足条件就交换值,较小的移到数组前面,较大的移到数组后面;
// 首先,排序算法的稳定性:通俗地讲就是能保证排序前2个相等的数其在序列的前后位置顺序和排序后它们两个的前后位置顺序相同。
int arrSort3[] = new int[] { 2, 3, 1, 5, 6, 7, 9 };
System.out.println("\n\n【No7:范例三:使用冒泡排序法排序】:");
int exchange2;
for (int si = 1; si < arrSort3.length; si++) {
for (int sj = 0; sj < arrSort3.length - si; sj++) {
if (arrSort3[sj] > arrSort3[sj + 1]) {// 把大于号改成小于号就变成了倒序哟~~
exchange2 = arrSort3[sj];
arrSort3[sj] = arrSort3[sj + 1];
arrSort3[sj + 1] = exchange2;
}
}
}
System.out.println(" 冒泡排序后输出:");
for (int k : arrSort3) {
System.out.print(k + "\t");
}
// No8.范例四:输出九宫格 // No9.实战:输出二维数组中所有元素之和
int arrSort4[][] = new int[][] { { 2, 3, 1, 5, 6, 7, 9 },
{ 2, 5, 7, 8, 10 }, { 3, 4, 5 } };
System.out.println("\n\n【No7:范例四:使用冒泡排序法排序】:");
int arrSort4Sum = 0;
System.out.println("二维数组arrSort4中的元素是");
for (int sumn = 0; sumn < arrSort4.length; sumn++) {
for (int summ = 0; summ < arrSort4[sumn].length; summ++) {
arrSort4Sum = arrSort4Sum + arrSort4[sumn][summ];
System.out.print(arrSort4[sumn][summ] + "\t");
}
System.out.println(); }
System.out.println("二维数组中所有元素之和:" + arrSort4Sum);
}
}

输出结果:
 第131页:数组的基本操作:
1.遍历数组
2.填充替换数组元素
3.对数组进行排序
4.复制数组
5.范例一:对比一维、二维数组所占内存
6.范例二:使用直接插入排序法排序
7.范例三:使用冒泡排序法排序
8.范例四:输出九宫格
9.实战:输出二维数组中所有元素之和 【No1:遍历数组】
1 月有 31 天 2 月有 29 天 3 月有 31 天
4 月有 30 天 5 月有 31 天 6 月有 30 天
7 月有 31 天 8 月有 31 天 9 月有 30 天
10 月有 31 天 11 月有 30 天 12 月有 31 天
遍历二维数组:
1 2 3 7 8 9 【No2:填充替换数组元素】
填充后所有的值都相同:
8 8 8 8 8
给指定范围填充值
8 6 6 8 8 【No3:对数组进行排序】
原数组:
8 10 4 1 5 6 3
排序后数组:
1 3 4 5 6 8 10 【No4:复制数组】
复制后的数组arrNew是:
1 2 3
复制后的数组arrNew2是:
4 5 【No5:范例一:对比一维、二维数组所占内存】
用一维数组占用内存总量为117M
用二维数组占用内存总量为117M 【No6:范例二:使用直接插入排序法排序】
排序前输出:
2 3 1 5 6 7 9
排序后输出:
1 2 3 5 6 7 9 【No7:范例三:使用冒泡排序法排序】:
冒泡排序后输出:
1 2 3 5 6 7 9 【No7:范例四:使用冒泡排序法排序】:
二维数组arrSort4中的元素是
2 3 1 5 6 7 9
2 5 7 8 10
3 4 5
二维数组中所有元素之和:77

No1_4.数组的基本操作_Java学习笔记的更多相关文章

  1. No1_5.字符串的基本操作_Java学习笔记

    import java.text.DecimalFormat; import java.text.NumberFormat; import java.util.Locale; import java. ...

  2. No1_3.数组初始化_Java学习笔记

    public class HelloArray { public static void main(String[] args) { // TODO Auto-generated method stu ...

  3. 数组和链表--Java学习笔记(一)

    版权声明: 本文由Faye_Zuo发布于http://www.cnblogs.com/zuofeiyi/, 本文可以被全部的转载或者部分使用,但请注明出处. 我是一个全职妈妈,两年前在上海一家人力资源 ...

  4. No1_6.字符串的基本操作2_Java学习笔记

    import java.util.Scanner; import java.util.regex.Pattern; public class HelloString2 { public static ...

  5. No2_5.类的高级特性_Java学习笔记_抽象类和成员内部类

    一.抽象类1.所谓抽象类,只声明方法的存在而不去实现它的类:2.抽象类不能被实例化,即不能实现其对象:3.abstract class 类名{ 类体 }4.包含一个或多个抽象方法的类必须声明成抽象类: ...

  6. No2_3.接口继承多态_Java学习笔记_多态

    ***多态***1.多态性:通常使用方法的重载(Overloading)和重写(Overriding)实现类的多态:2.重写之所以具有多态性,是因为父类的方法在子类中被重写,方法名相同,实现功能不同. ...

  7. No2_1.接口继承多态_Java学习笔记_接口

    接口.继承与多态 1.继承和多态是面向对象开发语言中的重要一个环节,使用得当,可以将整个程序的架构变得非常有弹性,减少代码冗余: 2.继承:复用定义好的类: 3.多态:可以动态调整对象的调用,降低对象 ...

  8. No1_7.类和对象_Java学习笔记

    一.面向对象的特点:a.封装:封装是面向对象的核心思想,将对象的属性和行为封装起来的载体就是类,类通常对客户隐藏其实现细节,这就是封装的思想: 保证了类内部数据的完整性,应用该类的用户不能轻易直接操纵 ...

  9. No1_2. 流程控制_java学习笔记

    import java.util.Scanner; import java.lang.Math; public class HelloForWhile { /** * 文档注释,程序名称:HelloF ...

随机推荐

  1. 【6】Laravel5.1的migration数据库迁移

    查看Laravel5.1的目录 当你配置好数据库后,在命令行执行下边的操作 php artisan migrate 打开数据库会发现,我们的数据库多了四个表,神奇吧! 打开任意一个migration查 ...

  2. js基础小总结之string&array&object

    一.数据类型之间的转换 string--->number :parseInt(string)/parseFloat(string); 注:在Date中,因为返回值date为单位为ms的字符串,将 ...

  3. 使用 JUnit 进行单元测试 - 教程

    tanyuanji@126.com 版本历史 JUnit 该教程主要讲解 JUnit 4.x 版本的使用,以及如何在Eclipse IDE 中如何使用JUnit   目录 tanyuanji@126. ...

  4. XJOI网上同步训练DAY2 T1

    [问题描述] 为了迎接校庆月亮中学操场开始施工.不久后操场下发现了很多古墓这些古墓中有很多宝藏.然而学生们逐渐发现自从操场施工之后学校的运气就开始变得特别不好.后来经过调查发现古墓下有一个太守坟由于操 ...

  5. QDataStream类参考(串行化数据,可设置低位高位,以及版本号),还有一个例子

    QDataStream类提供了二进制数据到QIODevice的串行化. #include 所 有成员函数的列表. 公有成员 QDataStream () QDataStream ( QIODevice ...

  6. GET: https://login.weixin.qq.com/cgi-bin/mmwebwx-bin/login? loginicon=true &uuid=odcptUu2JA==&tip=0

    GET: https://login.weixin.qq.com/cgi-bin/mmwebwx-bin/login? loginicon=true &uuid=odcptUu2JA==&am ...

  7. 【转】Android兼容性测试CTS Verifier-环境搭建、测试执行、结果分析

    原文网址:http://www.cnblogs.com/zh-ya-jing/p/4452675.html CTS Verifier算是CTS的一部分,需要手动进行,主要用于测试那些自动测试系统无法测 ...

  8. 利用智能手机(Android)追踪一块磁铁(二)

    在上一篇博客中提到了利用磁场强度推算传感器位置坐标的公式,下面就介绍怎么利用智能手机完成磁铁的追踪(任何具有磁感应器的装置均可以),这里主要是利用Android手机. 1:程序步骤: 首先将磁铁放置在 ...

  9. Yii2 分页类的扩展和listview引用

    Yii2 本身提供了不错分页选项供用户设置,但是实际项目中我们往往需要复杂一些的分页样式,例如下图所示的效果,上下翻页可用和不可用均用图标来替换.

  10. 《Java程序员面试笔试宝典》之为什么需要public static void main(String[] args)这个方法

    public staticvoid main(String[] args)为Java程序的入口方法,JVM在运行程序的时候,会首先查找main方法.其中,public是权限修饰符,表明任何类或对象都可 ...