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. DOM 之selection

    有关文章的集合 MOZILLA 开发者网络 selection: MOZILLA DEVELOPER NETWORK document.activeElement MOZILLA DEVELOPER ...

  2. Python正则匹配字母大小写不敏感在读xml中的应用

    需要解决的问题:要匹配字符串,字符串中字母的大小写不确定,如何匹配? 问题出现之前是使用字符串比较的方式,比如要匹配'abc',则用语句: if s == 'abc':#s为需要匹配的字符串 prin ...

  3. python保留指定文件、删除目录其他文件的功能(1)

    由于给客户的发布版本上客户改动了些代码和图片,我们这边给他们更新publish都是增量更新(开发提供更新指定的文件,我们提取出来给客户进行覆盖更新),但有时需要更新的文件较多导致不得不一个一个的进行查 ...

  4. JAVA语言对比C++语言的几个优点和自身的关键特性

    之所以写这篇博客不是为了比较JAVA语言和C++语言到底孰优孰劣,而是从语言本身出发进行对比总结程序编码设计上的差别.因水平有限,某些内容可能太过片面,欢迎指正和讨论. JAVA语言在设计上很好地借鉴 ...

  5. Javascript中Function,Object,Prototypes,__proto__等概念详解

    http://anykoro.sinaapp.com/2012/01/31/javascript%E4%B8%ADfunctionobjectprototypes__proto__%E7%AD%89% ...

  6. hdu 1599 find the mincost route

    http://acm.hdu.edu.cn/showproblem.php?pid=1599 floyd找最小环. #include <cstdio> #include <cstri ...

  7. 最新版AltiumDesignerSummer9下载+破解

    下载地址:ed2k://|file|AltiumDesignerSummer9Build9.3.1.19182.7z|1875307483|e65d364bf987fb5dcfb81c081a1562 ...

  8. delphi 打开文件夹并定位到一个文件(关键是/select参数)

    strFileName := FcxLV[nIndex].Items.Item[FcxLV[nIndex].ItemIndex].SubItems.Strings[0]; //路径  ShellExe ...

  9. 使用FastReport的UserDataSet时候,遇到TfrxMemoView内容过多而打印不全的问题

    解决方案很简单,就是把Memo所在的Band勾选Stretch就行了.另外还可勾选StartNewPage. 至于UserDataSet本身,猜测就是人为的构造一个类似数据库的集合,大致使用代码如下: ...

  10. Redhat Enterprise Linux中如何关闭SELinux?

    转自http://www.cnitblog.com/lywaml/archive/2005/06/21/468.html 红帽企业 Linux 4 包括了一个 SELinux 的实现.SELinux ...