image.png
image.png
package com.Hanjiangxue.javase.array;
//Java中的数组是一种引用数据类型,不属于基本数据类型，数组的父类是Object。
//数组实际上是一个容器，可以同时容纳多个元素。（数组是一个数据的集合）
//数组字面就是一组数据
//数组可以存储基本数据类型数据，也可以存储引用数据类型的数据
//数组因为是引用数据类型，所以数组对象在堆内存中。
//对于数组中如果存储的是Java对象的话，实际上存储的是对象的引用（内存地址）
//数组一旦创建，在Java中，数组长度不可变。
//数组分类：一维数组，二维数组，三维数组。。。。多维数组。
//所以的数组对象都有length属性，（Java自带的）。用来获取数组中元素个数。
//Java中的数组要求数组中元素类型统一，比如，int类型数组，只能存储int类型，Person类型数组只能存储Person类型。
//数组中存储的元素类型统一。
//数组在内存方面存储的时候，数组中的元素内存地址是连续的，存储的每一个元素都是有规则排列的，数组是一种简单的数据结构。
//所有的数组都是拿第一个小方框的内存地址作为整个数组的首地址。
//数组中每个元素都是有下标的，从0开始到length-1。通过下标对其存取。
//数组的优点：查询、查找、检索某个下标的元素效率高，
//为什么效率高？1、每一个元素的内存地址在空间存储上是连续的；2、每一个元素类型相同，所以占用空间大小一样；
//3、知道第一个元素内存地址，知道每一个元素占用空间大小，又知道下标，所以通过一个数字表达式就可以计算出某个下标上元素的内存地址，直接通过内存地址定位元素，所以数组的检索效率最高。
//数组中存储100个元素或存储100万个，效率相同的，因为数组是通过公式算出来的。
//缺点：1、由于为了保证数组中每个元素的内存地址连续，所以在数组上随机删除或增加元素的时候，效率较低，因为随机增删元素会涉及到后面元素统一向前或向后位移的操作。
//2、数组不能存储大数据量，为什么？因为很难在内存空间上找到一块特别大的连续的内存空间。
//注意：对于数组中最后一个元素的增删是没有影响的。
//声明、定义一个一维数组：int[] array1; double[] array2; boolean[] array3; String[] array4;Object[] array5;
//怎么初始化一个一维数组：包括静态初始化一维数组、动态初始化一维数组。
//静态初始化语法格式：int[] array = {100,2100,300,55};
//动态初始化语法格式：int[] array = new int[5];//这里的5表示数组的元素个数，初始化一个5个长度的int类型数组，每个元素默认值为0；
// String[] names = new String[6];//初始化6个长度的String类型数字，每个元素默认值为null。
public class ArrayTest01 {
public static void main(String[] args){
//使用静态初始化的方式，初始化int类型数组。
int[] a1 = {1,100,20,40,99};
//所有数组对象都有length属性。
System.out.println("数组中元素个数"+a1.length);
System.out.println("第一个元素="+a1[0]);
System.out.println("最后一个元素="+a1[a1.length-1]);
a1[0] = 11;
a1[a1.length - 1] = 11;
System.out.println("第一个元素="+a1[0]);
System.out.println("最后一个元素="+a1[a1.length-1]);
for(int i = 0;i < a1.length;i++){
System.out.println(a1[i]);
}
//a[6] ;//ArrayIndexOutOfBoundsException，数组越界异常
for(int i = a1.length-1;i >= 0;i--){
System.out.println(a1[i]);
}
//声明定义一个数组，采用动态方式初始化方式创建。
int[] a = new int[4]; //创建长度为4的int数组，每个元素默认为0
for(int i = 0;i < a.length;i++){
System.out.println(a[i]);
}
//初始化一个Object类型数组
Object[] obj = new Object[3];
for(int i = 0;i < obj.length;i++){
System.out.println(obj[i]);
}
String[] s = new String[4];
for(int i = 0;i < s.length;i++){
System.out.println(s[i]);
}
String[] str2 = {"abc","af","fjs"};
Object o1 = new Object();
Object o2 = new Object();
Object o3 = new Object();
Object[] objects = {o1,o2,o3};
for(int i = 0;i < objects.length;i++){
System.out.println(objects[i]);
}
Object[] objs = {new Object(),new Object(),new Object()};
//什么时候采用静态初始化，动态初始化。
//当确定数组中存储哪些数据时，采用静态初始化方式。
//当不确定数组中存储的哪些数据时，采用动态初始化方式。
}
}
image.png
package com.Hanjiangxue.javase.array;
public class ArrayTest02 {
public static void main(String[] args) {
int[] a1 = {1,2,3};
int a2[] = {3,4,5};
for(int i = 0;i < a1.length;i++){
System.out.println(a1[i]);
System.out.println(a2[i]);
}
int[] x= {1,2,3,4};
printArray(x);
String[] sar = {"agfa","gjae"};
printArray(sar);
}
public static void printArray(int[] array){
for(int i = 0;i < array.length;i++){
System.out.println(array[i]);
}
}
public static void printArray(String[] array){
for(int i = 0;i < array.length;i++){
System.out.println(array[i]);
}
}
}
package com.Hanjiangxue.javase.array;
public class ArrayTest03 {
public static void main(String[] args) {
int[] a= {1,2,3};
printArray(a);
int[] a2 = new int[4];
printArray(a2);
//直接传递静态数组这样写。
printArray(new int[]{2,3,4});
}
//用static不用new对象。
public static void printArray(int[] array){
for(int i = 0;i < array.length;i++){
System.out.println(array[i]);
}
}
}
package com.Hanjiangxue.javase.array;
//JVM调用main方法的时候，会自动传一个String数组过来。
public class ArrayTest04 {
public static void main(String[] args) {
//JVM传递过来的数组对象长度默认为0.
System.out.println(args.length);
String[] strs = new String[0];
//String[] str = {};//静态初始化数组。
printLength(strs);
//这个数组什么时候有值，用户可以在控制台输入参数，自动转换为String[] args。
//java ArrayTest04 ajgnl f
//JVM通过空格的方式分离，把ajgnl f转换成{“ajgnl”，“f”};传递给args。
}
public static void printLength(String[] args){
System.out.println(args.length);
}
}
package com.Hanjiangxue.javase.array;
public class ArrayTest05 {
public static void main(String[] args) {
if(args.length != 2){
System.out.println("使用程序系统时，请输入用户名和密码信息");
return;
}
String username = args[0];
String password = args[1];
//这样不会出现空指针异常。
//if("admin".equals(username) && "123".equals(password))
if(username.equals("admin") && password.equals("123")){
System.out.println("欢迎"+username+"回来");
System.out.println("欢迎继续使用系统");
}
}
}
package com.Hanjiangxue.javase.array;
//一维数组的深入，数组中存储的类型为：引用数据类型
public class ArrayTest06 {
public static void main(String[] args){
int[] array = {1,2,3};
for(int i = 0;i < array.length;i++){
int tmp = array[i];
System.out.println(tmp);
}
Animal a1 = new Animal();
Animal a2 = new Animal();
Animal[] animals = {a1,a2};
for(int i = 0;i < animals.length;i++){
Animal a = animals[i];
a.move();
//animals[i].move();
}
//动态初始化一个长度为2的Animal类型数组。
Animal[] ans = new Animal[2];
ans[1] = new Cat(); //Animal 可以存放一个Cat的对象，因为Cat是Animal的子类。
//创建一个Animal类型的数组，数组中存放Cat和Bird
Animal[] anis = {new Cat(),new Bird()};
for(int i = 0;i < anis.length;i++){
if(anis[i] instanceof Cat){
Cat cat = (Cat)anis[i];
cat.move();
}else if(anis[i] instanceof Bird){
Bird bird = (Bird)anis[i];
bird.move();
}
}
}
}
class Animal{
public void move(){
System.out.println("Animal");
}
}
class Cat extends Animal{
public void move(){
System.out.println("Cat");
}
}
class Bird extends Animal{
public void move(){
System.out.println("Bird");
}
}
package com.Hanjiangxue.javase.array;
//数组满了，数组扩容，先创建一个大容量的数组，再将数组的数据拷贝过去。
//数组扩容效率较低，因为涉及到拷贝的问题，所以在以后开发中尽量少的进行数组的拷贝。
public class ArrayTest08 {
public static void main(String[] args) {
//Java中数组拷贝方法
//System.arraycopy(src,spos,dest,dpos,length);
int[] src = {1,11,22,3,4};
int[] dest = new int[20];
// System.arraycopy(src,1,dest,3,2);
// for(int i =0;i < 20;i++){
// System.out.println(dest[i]);
// }
System.arraycopy(src,0,dest,0,src.length);
for(int i =0;i < 20;i++){
System.out.println(dest[i]);
}
//数组中存储的是引用数据类型可以拷贝
String[] strs = {"hello","whfonw","hofs"};
String[] newStrs = new String[20];
System.arraycopy(strs,0,newStrs,0, strs.length);
for(int i =0;i < 20;i++){
System.out.println(newStrs[i]);
}
Object[] objs = {new Object(),new Object()};
Object[] newObjs = new Object[10];
//拷贝的是内存地址。
System.arraycopy(objs,0,newObjs,0,objs.length);
for(int i =0;i < 10;i++){
System.out.println(newObjs[i]);
}
}
}
package com.Hanjiangxue.javase.array;
//二维数组是一个特殊的一维数组，特殊在这个一维数组当中每个元素是一个一维数组。
//三维数组：是一个特殊的二维数组，特殊在这个二维数组中每一个元素是一个一维数组。
//实际开发中使用最多的就是一维数组，二维数组很少使用，三维数组几乎不用。
//二维数组初始化 int[][] array = {{1,1,1},{2,3,4},{4,5,4}}
public class ArrayTest09 {
public static void main(String[] args) {
//一维数组
int[] array = {100,200,300};
System.out.println(array.length);//3
//二维数组
//以下代码中里面是5个一维数组
int[][] a= {
{100,200,300},
{40,30,409,0,4},
{3,49,39,30},
{0},
{2,4,4,3}
};
System.out.println(a.length);//5
System.out.println(a[0].length);//3
System.out.println(a[1].length);//5
System.out.println(a[3].length);//1
}
}
package com.Hanjiangxue.javase.array;
//关于二维数组中元素的读和改。
public class ArrayTest10 {
public static void main(String[] args) {
//二维数组
int[][] a = {
{34,4,65},
{100,200,300,444},
{0}
};
//请取出以上二维数组中的第一个一维数组
int[] a0 = a[0];
int a00 = a0[0];
System.out.println(a[0][0]);
System.out.println(a[1][2]);//第二个一维数组中的第三个元素。
a[0][2] = 1;
System.out.println(a[0][2]);//注意别越界。
}
}
package com.Hanjiangxue.javase.array;
public class ArrayTest11 {
public static void main(String[] args) {
String[][] array = {
{"java","oracle","c++"},
{"张三","李四","王五"},
{"lucy","jack","rose"}
};
//遍历
for(int i = 0;i < array.length;i++){
for(int j = 0;j < array[i].length;j++){
System.out.println(array[i][j]);
}
}
}
}
package com.Hanjiangxue.javase.array;
//动态初始化二维数组
public class ArrayTest12 {
public static void main(String[] args) {
//3行4列
//3个一维数组，每一个一维数组当中4个元素。
// int[][] array = new int[3][4];
//
// for(int i = 0;i < array.length;i++){
// for(int j = 0;j < array[i].length;j++){
// System.out.println(array[i][j]);
// }
// }
int[][] a = {
{1,2,3,4},
{4,4,5,3},
{3,4,3,3},
{3,4,2,5}
};
printArray(a);
//记住new
printArray(new int[][]{{1,3,4},{3,4,5},{3,4}});
}
public static void printArray(int[][] array){
for(int i = 0;i < array.length;i++){
for(int j = 0;j < array[i].length;j++){
System.out.println(array[i][j]);
}
}
}
}
package com.Hanjiangxue.javase.array;
import java.util.Arrays;
public class ArraysTest01 {
public static void main(String[] args) {
int[] arr = {11,2,44,24,65,1};
Arrays.sort(arr);
for(int i = 0;i < arr.length;i++){
System.out.println(arr[i]);
}
}
}
package com.Hanjiangxue.javase.array;
public class BubbleSort {
public static void main(String[] args) {
int[] arr = {13,23,55,73,16,5,3,7,755,22,5};
//冒泡排序,相邻的两个数值进行比较。前面数值如果大则交换，否则继续向后遍历。
for(int i = 0;i < arr.length;i++){
for(int j = 0;j < arr.length-i-1;j++){
if(arr[j] > arr[j+1]){
int tmp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = tmp;
}
}
}
for(int i = 0;i < arr.length;i++){
System.out.println(arr[i]);
}
}
}
package com.Hanjiangxue.javase.array;
public class SelectSort {
public static void main(String[] args) {
int[] arr = {13,23,55,73,16,5,3,7,755,22,5};
//选择排序，每次选择最小的与最前面的数据交换,min为最小值的下标。
for(int i = 0;i < arr.length-1;i++){
int min = i;
for(int j = i+1;j < arr.length;j++){
if(arr[min] > arr[j]){
min = j;
}
}
if(min != i){
int tmp = arr[i];
arr[i] = arr[min];
arr[min] = tmp;
}
}
for(int i = 0;i < arr.length;i++){
System.out.println(arr[i]);
}
}
}
package com.Hanjiangxue.javase.array;
public class ArrayBinSearch {
public static void main(String[] args) {
int[] arr = {13,23,55,73,16,5,3,7,755,22,5};
//顺序查找
for(int i = 0;i < arr.length;i++){
if(arr[i] == 755){
System.out.println("下标为"+i);
break;
}
}
//选择排序
for(int i = 0;i < arr.length-1;i++){
int min = i;
for(int j = i+1;j < arr.length;j++){
if(arr[min] > arr[j]){
min = j;
}
}
if(min != i){
int tmp = arr[i];
arr[i] = arr[min];
arr[min] = tmp;
}
}
//二分查找
int index = binSearch(arr,1);
System.out.printf(index == -1 ? "不存在" : "下标"+index);
}
public static int binSearch(int[] arr,int n){
int l = 0;
int r = arr.length-1;
while(l <= r){
int mid = (l+r)/2;
if(arr[mid] == n){
return mid;
}else if(arr[mid] < n){
l = mid + 1;
}else{
r = mid - 1;
}
}
return -1;
}
}
import java.util.Arrays;
public class ArraysTest02 {
public static void main(String[] args) {
//java.util.Arrays:工具类中哪些方法。
//所有方法都是静态的，主要使用类名调用。
int[] arr = {13,23,55,73,16,5,3,7,755,22,5};
Arrays.sort(arr);
int index = Arrays.binarySearch(arr,5);
System.out.println(index);
}
}
网友评论