day05_数组_20150805
-------------------------回顾:---------------------------
1.循环:反复执行一段相同或相似的代码
2.循环三要素:
1)循环变量的初始化
2)循环的条件(以循环变量为基础)
3)循环变量的改变(向着循环的结束变)
循环变量: 在循环过程中所改变的那个量
3.循环结构:
1)while:先判断后执行
2)do...while:先执行后判断
第1要素与第3要素相同时
3)for:应用率最高的
4.break:跳出循环
continue:跳过循环体中剩余语句而进入下一次循环=====================笔记:========================
1.各种循环结构的更佳适用情况
1)while: "当..."循环
2)do...while: "直到..."循环
第1要素与第3要素相同时首选
3)for: 固定次数循环----应用率最高的
2.嵌套循环:
1)循环中套循环
2)多行多列时使用，外层循环控制行，内层循环控制列
3)执行过程: 外层循环走一次，内存循环走所有次
4)能用一层就不用两层，能用两层就不用三层，层数越少越好
如果超过三层循环，说明设计有问题
5)break只能跳出一层循环
3.程序=算法+数据结构
算法:解决问题的流程/步骤(顺序、分支、循环)
数据结构:将数据按照某种特定的结构来保存--数怎么存
设计合理的数据结构会导致好的算法
4.数组:
1)相同数据类型元素的集合
2)数组是一种数据类型(引用类型)
3)数组的定义:int[] arr = new int[4];
4)数组的初始化: 给数组中的元素赋值
int[] arr = new int[4]; //0,0,0,0int[] arr = {1,4,5,7}; //1,4,5,7
int[] arr = new int[]{1,4,5,7}; //1,4,5,7
int[] arr;
arr = {1,4,5,7}; //编译错误，此方式只能声明同时初始化
arr = new int[]{1,4,5,7}; //正确
5)数组的访问: 通过下标/索引来访问数组中的元素
下标从0开始，最大到.length-1
int[] arr = new int[4];System.out.println(arr.length); //4
arr[0] = 100; //给arr中的第1个元素赋值为100
arr[1] = 200;
arr[2] = 300; //给arr中的第3个元素赋值为300
arr[3] = 400;
arr[4] = 500; //数组下标越界异常
System.out.println(arr[arr.length-1]); //输出最后一个元素
6)数组的遍历:
int[] arr = new int[10];for(int i=0;i<arr.length;i++){ //遍历arr数组
arr[i] = 100; //给arr中每个元素都赋值为100
}
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
for(int i=arr.length-1;i>=0;i--){
System.out.println(arr[i]);
}
7)数组的复制:
System.arraycopy(a,1,a1,0,4);int[] a1 = Arrays.copyOf(a,6);
a = Arrays.copyOf(a,a.length+1);
8)数组的排序:
Arrays.sort(arr); //升序排
----------------------------------------总结---------------------------------------
1.java中可以动态声明数组----具体用法见代码
Myfoundametal.day05.Test03.java
代码如下：
package day05;
import java.util.Scanner;
//可以动态声明数组
public class Test03 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int[] arr = new int[n];
for(int i=0;i<arr.length;i++){
arr[i]=(int)(Math.random()*100);
}
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+"\t");
}
System.out.println("\n");
int num = 3;
int[] arr2=new int[num*3];//正确
System.out.println("arr2.length="+arr2.length);
}
}
2.数组复制方式
1）System.arraycopy方法
--public static void arraycopy(Object src, int srcPos,Object dest, int destPos, int length)
----src：源数组
----srcPos：源数组中的起始位置
----dest：目标数组
-----destPos: 目标数组中的起始位置
-----length：要复制的数组元素的数量
代码示例：
package day05;
import java.lang.reflect.Array;
import java.util.Arrays;
public class Test01 {
public static void main(String[] args){
int[ ] arr = new int[]{ 4,5,6,8};
System.out.println(arr);
//int [ ] arr1 = new int [ 5 ] {10,20,30,40,50 } ;//编译错误
arr=Arrays.copyOf(arr, 5);
System.out.println(arr);
int[] arr2=new int[2];
System.arraycopy(arr, 0, arr2, 0, 2);
System.out.println(arr2.toString());
//System.out.println(Array.getLength(arr2));
}
}
2）java.util.Arrays.copyOf方法
--类型[ ] newArray = Arrays.copyOf ( 类型[ ] original , int newLength )
----生成的新数组是原始数组的副本；
---newLength小于源数组，则进行截取；（自己通过代码演示效果）；
---newLength大于源数组，则用0或 null进行填充；
用法代码示例：
package day05;
import java.util.Arrays;
public class MaxOfArray {
public static void main(String[] args) {
int[] arr = new int[10];
for(int i=0;i<arr.length;i++){
arr[i]=(int)(Math.random()*100);
}
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+"\t");
}
System.out.println();
//找出最大值
int max=arr[0];
for(int i=1;i<arr.length;i++){
if(arr[i]>max){
max=arr[i];
}
}
System.out.println("Max="+max);
//1--System.arraycopy();
int[] arrTemp = new int[arr.length+1];
System.arraycopy(arr, 0, arrTemp, 0, arr.length);
arrTemp[arrTemp.length-1] = max;
arr = arrTemp;
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+"\t");
}
System.out.println();
//2--Arrays.copyOf();
arr = Arrays.copyOf(arr, arr.length+1);
arr[arr.length-1] = max;
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+"\t");
}
System.out.println();
int[] arr1=new int[8];
System.arraycopy(arr, 0, arr1, 1, 7);
for(int i=0;i<arr1.length;i++){
System.out.print(arr1[i]+"\t");
}
System.out.println();
arr = arr1;
arr1[0] = 999;
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+"\t");
}
}
}
3.冒泡原理
1）n个数冒n-1轮
2）每一轮都是从第一个元素开始比
3）每一次都是和他的下一个元素比
4）冒出来的数就不参与比较了
示例代码：
package day05;
import java.util.Arrays;
public class SortDemo {
public static void main(String[] args) {
int[] arr=new int[5];
for(int i=0;i<arr.length;i++){
arr[i]=(int)(Math.random()*100);
}
//1--java.util.Arrays.sort();
//Arrays.sort(arr);
//2--冒泡
for(int i=0;i<arr.length-1;i++){
for(int j=0;j<arr.length-1-i;j++){
if(arr[j]>arr[j+1]){
int t=arr[j];
arr[j]=arr[j+1];
arr[j+1]=t;
}
}
}
//输出
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
}
}
4.java.util.Random;
--Random ran = new Random();
--Myfoundametal.day05.RandomDemo.java
代码如下：
package day05;
import java.util.Random;
import java.util.Arrays;
public class RandomDemo {
public static void main(String[] args) {
Random ran = new Random();
int[] arr=new int[10];
for(int i=0;i<arr.length;i++){
arr[i]=ran.nextInt(100);
}
System.out.println(Arrays.toString(arr));
}
}
5.java.util.Arrays;
-- Arrays.sort(arr); --排序
-- Arrays.toString(arr); --打印数组元素
---可以把数组的元素都打印出来，如[1,2,3];
---------------遗留问题---------------------
1.native关键字？
答：
其实就是JNI。
native是方法修饰符。Native方法是由另外一种语言（如c/c++，FORTRAN，汇编）实现的本地方法。
因为在外部实现了方法，所以在java代码中，就不需要声明了，有点类似于借口方法。
Native可以和其他一些修饰符连用，但是abstract方法和Interface方法不能用native来修饰。
（先写这些，后来学到再详细了解）
2.Array类和Arrays类
答：java.lang.reflect.Array
此类提供了动态创建和访问 Java 数组的方法。
java.util.Arrays
此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。
二者有些区别，具体看文档吧。
前者倾向于操作数组的单个元素，后者倾向于操作整个数组。
-------------------------------------------------------------------------------
555
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
