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. 搭建lamp环境

    虚拟机始终是虚拟机,还是linux用起来舒服得多.话不多说,回到我们的老本行,linux下进行lamp环境搭建吧. 一.安装 1.Apache sudo apt-get install apache2 ...

  2. 从运行原理及使用场景看Apache和Nginx

    用正确的工具,做正确的事情. 本文只作为了解Apache和Nginx知识的一个梳理,想详细了解的请阅读文末参考链接中的博文. Web服务器 Web服务器也称为WWW(WORLD WIDE WEB)服务 ...

  3. hdu 5305Friends

    题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=5305 Problem Description There are n people and m pai ...

  4. MHA环境的搭建

    MHA简介: MHA(Master High Availability)目前在MySQL高可用方面是一个相对成熟的解决方案,它由日本DeNA公司youshimaton(现就职于Facebook公司)开 ...

  5. uiautomator <一> 编译运行

    uiautomator testcase 一.新建Java工程 二.导入lib包 android.jar 和 uiautomator.jar ,选中点击右键Add to buildPath 三.新建测 ...

  6. ASP.NET MVC3快速入门——第四节、添加一个模型

    在本节中我们将追加一些类来管理数据库中的电影.这些类将成为我们的MVC应用程序中的“模型”部分.我们将使用一个.NET Framework的被称之为“Entiry Framework”的数据访问技术来 ...

  7. java.lang.OutOfMemoryError: GC overhead limit exceeded 问题分析和解决(转)

    在项目历史数据导入过程中,出现了应用无法访问的情况.立刻对Weblogic进行分析,发现Weblogic的内存.线程等性能良好,Server也是Running的状态.随后查看了Weblogic日志,在 ...

  8. bzoj1750 [Usaco2005 qua]Apple Catching

    Description It is a little known fact that cows love apples. Farmer John has two apple trees (which ...

  9. 选择排序(Selection Sort)

    选择排序就是在选择数组元素上做文章,关键是如何选择?选择的标准是什么?选择之后放在哪?所有这些都是选择排序的问题. 选择排序算法中,通常会有以下操作: 从数组第一个元素开始. 遍历整个数组,找到最小的 ...

  10. jdbc连接数据库工具类

    import java.lang.reflect.Field; import java.sql.Connection; import java.sql.DriverManager; import ja ...