package pshuzu;
/*
* 数组：
* 1、数组是一种引用类型
*
* 2、数组是一种简单的数据结构，线性的结构
*
* 3、数组是一个容器，可以用来存储其他元素
* 数组是可以存储任意数据类型的元素
*
* 4、数组分为：一维数组，二维数组，三维数组，多维数组
*
* 5、数组中存储的元素类型是统一的
*
* 6、数组长度不可改变。数组一且创建长度是不可变的，固定的
*/
public class ArrayTest01 {
public static void main(String[] args) {
//声明一个一维数组，用来存储int类型
int[] a1 = {100,200,300}; //这种方式称作“静态初始化一维数组”
//boolean类型的数组
boolean[] b1 = {true,false,true};
//String类型的数组
String[] strs = {"AB","CD","EF"};
//byte数组
byte[] b2 = {1,2,3};
//char数组
char[] c1 = {'a','b','c'};
//Object数据
Object o1 = new Object();
Object o2 = new Object();
Object o3 = new Object();
Object[] objs = {o1,02,03};
}
}
package pshuzu;
/*
* 数组中存储元素的类型是统一的，每一个元素在内存中所占的空间大小是相同的，
* 知道数组的首元素的内存地址，要查找的元素只要知道下标就可以快速的计算出偏移量，
* 通过首元素内存地址加上偏移量快速计算出要查找元素的内存地址，
* 通过内存地址快速定位该元素，所以数组查找元素的效率较高
*
* 随机的对数组进行增删元素，当增加的元素的时候，
* 为了保证数组中元素在空间储存上是有序的，所以被添加元素位置后面的所有元素都要向后移动，
* 删除元素也是，后面所有的元素要向前移动。所以数组的增删元素的效率很低。
*
* 初始化一维数组有两种方式：
* 1、静态初始化
* 2、动态初始化
*/
public class ArrayTest02 {
public static void main(String[] args) {
//静态初始化一个int类型的一维数组
int[] a1 = {10,12,31};
//取得第一个元素
System.out.println("第一个元素：" + a1[0]);
System.out.println("最后一个元素：" + a1[2]);
//取得个数
System.out.println("数组中元素的个数是:" + a1.length);
//遍历一维数组
for(int i=0; i<a1.length; i++){
System.out.println(a1[i]);
}
//将第2个元素修改成100
a1[1] = 100;
System.out.println("==============");
for(int i=0; i<a1.length; i++){
System.out.println(a1[i]);
}
}
}
package pshuzu;
/*
* 动态初始化一维数组
*
* 1、动态初始化一维数组，会先在堆内存中分配这个数组，并且数组中每一个元素都采用默认值
* byte, short, int, long 0
* float double 0.0
* boolean false
* char \u0000
* 引用 nu11
*/
public class ArrayTest03 {
public static void main(String[] args) {
//动态声明一个int类型的数组，最多可以存储4个
int[] a1 = new int[4];
//遍历
for(int i=0; i<a1.length; i++){
System.out.println(a1[i]); //0 0 0 0
}
//赋值
a1[0] = 21;
a1[1] = 22;
a1[2] = 23;
a1[3] = 24;
for(int i=0; i<a1.length; i++){
System.out.println(a1[i]);
}
//引用类型数组
Object[] objs = new Object[3];
for(int index=0; index<objs.length; index++){
Object o = objs[index];
//o.toString(); //注意空指针异常，因为引用类型的数组默认值是null
System.out.println(o); //null null null 不会空指针异常，底层已处理
}
}
}
package pshuzu;
/*
* 什么时候使用动态初始化，什么时候使用静态初始化？
* 1、无论是动态初始化还是静态初始化，最终的内存分布都是一样的
*
* 2、如果在创建数组的时候，知道数组中应该存储什么数据，这个时候当然采用静态初始化方式
* 如果在创建数组的时候，无法预测到数组中存储什么数据，只是先开辟空间，则使用动态初始化方式
*/
public class ArrayTest04 {
public static void main(String[] args) {
//静态初始化
int[] a1 = {10,12,31};
//动态初始化
int[] a2 = new int[4];
}
}
package pshuzu;
/*
* 深入一维数组
*/
public class ArrayTest05 {
public static void main(String[] args) {
//创建一个数组，这个数组既可以存储Dog，也能存储Cat
Animal[] as = new Animal[4];
//给数组每个元素赋值
Dog d1 = new Dog();
Dog d2 = new Dog();
Cat c1 = new Cat();
Cat c2 = new Cat();
as[0] = d1;
as[1] = d2;
as[2] = c1;
as[3] = c2;
//需求：遍历数组，取出每个对象，如果是Dog执行eat方法，如果是Cat执行move方法
for(int i=0; i<as.length; i++){
Animal a = as[i];
//强制类型转换(向下转型)
if(a instanceof Cat){
Cat c = (Cat)a;
c.move();
}else if(a instanceof Dog){
Dog d = (Dog)a;
d.eat();
}
}
}
}
class Animal{
}
class Dog extends Animal{
public void eat(){
System.out.println("Dog eat");
}
}
class Cat extends Animal{
public void move(){
System.out.println("Cat move");
}
}
package pshuzu;
/*
* 方法调用的时候，也可以这样传递一个数组
*/
public class ArrayTest06 {
public static void main(String[] args) {
//第一种方式
int[] a = {12,3,4,5,6};
m1(a);
//第二种方式
m1(new int[]{34,2,3,4});
}
public static void m1(int[] a){
for(int i=0; i<a.length; i++){
System.out.println(a[i]);
}
}
}
package pshuzu;
/*
* 需要使用 运行 来执行以下代码
*
* 关于main方法中的参数列表 string[] args
*
* 1、String[] args是专门用来接收命令行参数的
*
* 2、例如：java ArrayTest07 abc def aaa
* JVM在调用ArrayTest07类的main方法之前，
* 先 "abc def aaa" 这个字符串以"空格"的方式分割，
* 然后存储在String数组中
*/
public class ArrayTest07 {
public static void main(String[] args) {
System.out.println("String类型的数组中元素的个数是：" + args.length);
//需求说明：运行该软件的时候必须提供用户名和密码
//格式：java ArrayTest07 username password
//如果用户没有提供足够的参数，则退出系统
if(args.length != 2){
System.out.println("想要进入系统，要输入:java ArrayTest07 username password");
return;
}
//参数提供正确，如果用户名是admin，密码是123则成功
String username = args[0];
String password = args[1];
//java中比较字符串是否相等，必须使用equals方法
//String类型是SUN提供，已经equals重写了。比较的是内容
if("admin".equals(username) && "123".equals(password)){
//if(username.equals("admin") && password.equals("123")){ //上面方法可以避免空指针异常
System.out.println("登陆成功");
}else{
System.out.println("登录失败");
}
}
}
package pshuzu;
/*
* 关于数组的拷贝
*
* 以下讲解的是JDK中提供好的方法，直接调用
*/
public class ArrayTest08 {
public static void main(String[] args) {
int[] src = {1,2,3,4,5,6};
int[] dest = {10,11,12,13,14,15};
//把src中的3,4,5拷贝到dest数组从13开始
//System.arraycopy(源数组，源数据的开始下标，目标数组，目标数组的开始下标，拷贝长度);
System.arraycopy(src, 2, dest, 3, 3);
//遍历
for(int i=0; i<dest.length; i++){
System.out.println(dest[i]);
}
}
}
package pshuzu;
/*
* 二维数组特点：
* 1、二维数组是一个特殊的一维数组
* 2、特殊的一维数组，特殊在这个一维数组中每一个元素都是一维数组
*/
public class ArrayTest09 {
public static void main(String[] args) {
//静态初始化二维数组
int[][] a = {{1,2,3},{45,55},{0},{10,23,85,99}};
//以上这个数组有多少个一维数组
System.out.println(a.length + "个一维数组");
//获取第1个一维数组
int[] a0 = a[0];
int a00 = a0[0];
System.out.println(a00);
//另一种方式
System.out.println(a[0][0]);
//获取最后一个一维数组的最后一个元素
System.out.println(a[3][3]);
//遍历二维数组
//先外后里
for(int i=0; i<a.length; i++){
//对一维数组a[i]进行遍历
for(int j=0; j<a[i].length; j++){
System.out.print(a[i][j] + " ");
}
System.out.println();
}
}
}
package pshuzu;
/*
* 关于二维数组的动态初始化
*/
public class ArrayTest10 {
public static void main(String[] args) {
//3个一维数组
//每一个一维数组中有4个元素
int[][] a = new int[3][4];
//遍历
for(int i=0; i<a.length; i++){
for(int j=0; j<a[i].length; j++){
System.out.print(a[i][j] + " ");
}
System.out.println();
}
//赋值
a[1][2] = 100;
}
}
package pshuzu;
public class ArrayTest11 {
public static void main(String[] args) {
m1(new int[][]{{1,2,3},{5,6,7},{8,9,0}});
}
public static void m1(int[][] a){
for(int i=0; i<a.length; i++){
for(int j=0; j<a[i].length; j++){
System.out.print(a[i][j] + " ");
}
System.out.println();
}
}
}
package pshuzu;
import java.util.Scanner;
public class KeyInput {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
//程序执行到此处，停下来，等待用户的输入
String userInput = s.next();
System.out.println("您输入了：" + userInput);
}
}
浙公网安备 33010602011771号