Java 数组
package com.fish.array;
/*
数组：数组是存储同一种数据类型数据的集合容器。
数组的定义格式：
数据类型[] 变量名 = new 数据类型[长度];
分析数组：
左边： int[] arr 声明了一个int类型的的数组变量，变量名为arr。
int : 表示该数组容器只能存储int类型的数据。
[] ： 这是一个数组类型。
arr ： 变量名.
右边：new int[4]; 创建了一个长度为4的int类型数组对象。
new ： 创建数组对象的关键字。
int: 表示该数组对象只能存储int类型数据。
[]： 表示是数组类型。
4: 该数组最多能存储4个数据。数组的容量。
数组的好处：对分配到数组对象中每一个数据都分配一个编号（索引值、角标、下标）,索引值的范围是从0开始，最大是： 长度-1.
局部变量： 如果一个变量是在一个方法（函数）的内部声明的，那么该变量就是一个局部变量。
成员变量： 成员变量就是定义在方法之外，类之内的.
*/
public class Demo4{
public static void main(String[] args){
//定义一个数组
int[] arr = new int[4];
arr[0] = 10;
arr[1] = 30;
arr[2] = 50;
arr[3] = 90;
//System.out.println("数组的容量："+ arr.length);//数组的有一个length 的属性，可以查看数组 的容量。
//System.out.println("arr[2] = "+ arr[2]);
//查看数组中的所有数据。
for(int index = 0 ; index<arr.length ; index++){
System.out.println(arr[index]);
}
}
}
package com.fish.array;
/*
数组的内存分析:
*/
public class Demo5{
public static void main(String[] args){
/*
int[] arr1 = new int[2];
int[] arr2 = new int[2];
arr1[1] = 10;
arr2[1] = 20;
System.out.println(arr1[1]); // 10
int[] arr1 = new int[2];
arr1[1] = 100;
int[] arr2 = arr1;
arr1[1] = 10;
arr2[1] = 20;
System.out.println(arr1[1]); // 20
*/
}
}
package com.fish.array;
/*
数组中最常见的问题：
1. NullPointerException 空指针异常
原因： 引用类型变量没有指向任何对象，而访问了对象的属性或者是调用了对象的方法。
2. ArrayIndexOutOfBoundsException 索引值越界。
原因：访问了不存在的索引值。
*/
public class Demo6{
public static void main(String[] args){
/*
int[] arr = new int[2];
arr = null ; //null 让该变量不要引用任何的对象。 不要记录任何 的内存地址。
arr[1] = 10;
System.out.println(arr[1]);
*/
int[] arr = new int[4];
arr[0] = 10;
arr[1] = 30;
arr[2] =40;
arr[3] = 50;
//System.out.println(arr[4]); //访问索引值为4的内存空间存储的值。
for(int index = 0 ; index<=arr.length ; index++){ //遍历的时候不能=length，只能小于length
System.out.print(arr[index]+",");
}
}
}
package com.fish.array;
/*
数组的初始化方式：
动态初始化:
数据类型[] 变量名 = new 数据类型[长度];
静态初始化：
数据类型[] 变量名 = {元素1，元素2.....};
如果程序一开始你就已经确定了数据，那么这时候建议使用静态初始化。如果
数据一开始还不太明确，这时候就建议使用动态初始化。
*/
public class Demo7{
public static void main(String[] args){
//动态初始化
//int[] arr = new int[10];
//静态初始化
int[] arr = {10,20,30,40,50};
for(int index = 0 ; index<arr.length ; index++){
System.out.print(arr[index]+",");
}
/*
int[] arr = new int[50];
Scanner scanner = new Scanner(System.in);
for(int i = 0 ; i< arr.length ; i++){
arr[i] = scanner.nextInt();
}
*/
}
}
package com.fish.array;
/*
需求： 定义一个函数接收一个int类型的数组对象，找出数组对象中的最大元素返回给调用者。
*/
public class Demo8{
public static void main(String[] args) {
int[] arr = {-12,-14,-5,-26,-4};
int max = getMax(arr);
System.out.println("最大值："+ max);
}
public static int getMax(int[] arr){
int max = arr[0]; //用于记录最大值
for(int i = 1 ; i < arr.length ; i++){
if(arr[i]>max){ //如果发现有元素比max大，那么max变量就记录该元素。
max = arr[i];
}
}
return max;
}
}
package com.fish.array;
/*
需求：定义一个函数接收一个int类型的数组对象, 把数组中的最大值放在数组中的第一位。
选择排序(直接排序)：使用一个元素与其他 的元素挨个比较一次，符合条件交换位置。
*/
public class Demo9{
public static void main(String[] args){
int[] arr = {12,5,17,8,9}; //对于5元素的数组，只需要找出4个最大值就可以排序了。
selectSort(arr);
}
public static void selectSort(int[] arr){
//把最大值放在首位置。
for(int j = 0; j<arr.length-1; j++){ // 控制的是轮数。
for(int i = j+1 ; i<arr.length ; i++){ // 找出最大值
if(arr[i]>arr[j]){
//交换位置
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
/*
//把老二放在第二个位置
for(int i = 2 ; i< arr.length ; i++){
if(arr[i]>arr[1]){
int temp = arr[i];
arr[i] = arr[1];
arr[1] = temp;
}
}
//把老三放在第三个位置
for(int i = 3 ; i< arr.length ; i++){
if(arr[i]>arr[2]){
int temp = arr[i];
arr[i] = arr[2];
arr[2] = temp;
}
}
//把老四放在第四个位置
for(int i = 4 ; i< arr.length ; i++){
if(arr[i]>arr[3]){
int temp = arr[i];
arr[i] = arr[3];
arr[3] = temp;
}
}
*/
//遍历数组，查看效果
System.out.print("目前的元素：");
for (int i = 0 ; i<arr.length ;i++){
System.out.print(arr[i]+",");
}
}
}
package com.fish.array;
/*
需求： 定义一个函数接收一个int类型的数组对象, 把数组中的最大值放在数组中的最后一位。
冒泡排序：冒泡排序的思想就是使用相邻的两个 元素挨个比较一次，符合条件交换位置。
*/
public class Demo10{
public static void main(String[] args){
int[] arr = {12,8,17,5,9}; // 最大的索引值: 4 容量：5
bubbleSort(arr);
}
public static void bubbleSort(int[] arr){
// 把最大值放在最后一个位置
for(int j = 0 ; j<arr.length-1 ; j++){ //控制轮数
for(int i = 0 ; i<arr.length-1-j ; i++){ // 找出一个最大值
//相邻的元素比较
if(arr[i]>arr[i+1]){
int temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}
}
/*
//把老二放在倒数第二个位置上。
for(int i = 0 ; i <arr.length-1-1 ; i++){
if(arr[i]>arr[i+1]){
int temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}
//把老三放在倒数第三个位置上。
for(int i = 0 ; i <arr.length-1-2 ; i++){
if(arr[i]>arr[i+1]){
int temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}
//把老四放在倒数第四个位置上。
for(int i = 0 ; i <arr.length-1-3 ; i++){
if(arr[i]>arr[i+1]){
int temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}
*/
//遍历数组，查看效果
System.out.print("目前的元素：");
for (int i = 0 ; i<arr.length ;i++){
System.out.print(arr[i]+",");
}
}
}
package com.fish.array;
/*
需求：定义一个函数接收一个数组对象和一个要查找的目标元素，函数要返回该目标元素在
数组中的索引值，如果目标元素不存在数组中，那么返回-1表示。
折半查找法(二分法): 使用前提必需是有序的数组。
*/
public class Demo12
{
public static void main(String[] args)
{
int[] arr = {12,16,19,23,54};
//int index = searchEle(arr,23);
int index = halfSearch(arr,116);
System.out.println("元素所在的索引值是："+ index);
}
public static int halfSearch(int[] arr, int target){
//定义三个变量分别记录最大、最小、中间的查找范围索引值
int max = arr.length-1;
int min = 0;
int mid = (max+min)/2;
while(true){
if(target>arr[mid]){
min = mid+1;
}else if(target<arr[mid]){
max = mid -1;
}else{
//找到了元素
return mid;
}
//没有找到的情况
if (max<min){
return -1;
}
//重新计算中间索引值
mid = (min+max)/2;
}
}
public static int searchEle(int[] arr, int target){
for(int i = 0 ; i<arr.length ; i++){
if(arr[i]==target){
return i;
}
}
return -1;
}
}
package com.fish.array;
/*
需求： 定义 一个函数接收一个char类型的数组对象,然后翻转数组中的元素。
char[] arr = {'a','b','c','d','e'};
*/
public class Demo13
{
public static void main(String[] args)
{
//System.out.println("Hello World!");
char[] arr = {'a','b','c','d','e'};
reverse(arr);
}
public static void reverse(char[] arr){
for(int startIndex = 0 ,endIndex = arr.length-1 ; startIndex<endIndex ; startIndex++,endIndex--){
char temp = arr[startIndex];
arr[startIndex] = arr[endIndex];
arr[endIndex] = temp;
}
//遍历数组，查看效果
System.out.print("目前的元素：");
for (int i = 0 ; i<arr.length ;i++){
System.out.print(arr[i]+",");
}
}
}
package com.fish.array;
/*
toString();
排序（sort）
找元素在数组中的位置(二分查找法) binarySearch
数组的工具类（Arrays）：
作业1：自定实现一个Arrays的toString方法。
*/
import java.util.*;
public class Demo14
{
public static void main(String[] args)
{
int[] arr = {12,3,1,10,8};
//排序的方法
Arrays.sort(arr);
String info = Arrays.toString(arr);
System.out.println("数组的元素："+ info);
// 1, 3, 8, 10, 12
int index = Arrays.binarySearch(arr,9);// 二分法查找 : 如果能在数组中找到对应 的元素，那么就返回该数据的索引值，如果没有找到那么就返回一个负数表示。
System.out.println("找到的索引值："+ index);
}
}
package com.fish.array;
/*
二维数组：二维数组就是数组中的数组。
一根变量
一盒 20根 一维数组
一条 10包 20根 二维数组
二维数组的定义格式：
数据类型[][] 变量名 = new 数据类型[长度1][长度2];
长度1：一条烟有多少盒。
长度2：一盒烟有多少根。
二维数组的初始化方式：
动态初始化:
数据类型[][] 变量名 = new 数据类型[长度1][长度2];
静态初始化：
数据类型[][] 变量名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...} ..}
*/
class Demo15{
public static void main(String[] args)
{
//定义了一个二维数组
int[][] arr = new int[3][4];
arr[1][1] = 100;
/*
System.out.println("二维数组的长度："+ arr.length); //3
System.out.println("二维数组的长度："+ arr[1].length); //4
*/
System.out.println("数组的元素："+ arr[1][1]);
}
}
package com.fish.array;
/*
静态初始化：
数据类型[][] 变量名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...} ..}
*/
public class Demo16
{
public static void main(String[] args)
{
int[][] arr = {{10,11,9},{67,12},{33,35,39,40}};
//遍历二维数组
for(int i = 0; i <arr.length ; i++){
for(int j = 0 ; j<arr[i].length ; j++){
System.out.print(arr[i][j]+",");
}
//换行
System.out.println();
}
}
// 定义一个二维数组，然后计算二维数组中偶数元素的总和。
}
package com.fish.array;
/*
数组的特点：
1. 数组只能存储同一种数据类型的数据。
2. 数组是会给存储到数组中的元素分配一个索引值的，索引值从0开始，最大的索引值是length-1；
3. 数组一旦初始化，长度固定。
4. 数组中的元素与元素之间的内存地址是连续的。
*/
public class Demo17{
public static void main(String[] args){
int[] arr = new int[3];
arr = new int[4];
System.out.println(arr.length);
}
}
/*
11.目前有数组” int[] arr = {11,2, 4, 2, 10, 11}，
定义一个函数清除该数组的重复元素，返回的数组存储了那些非重复的元素而且数组不准浪费长度。
分析：
1. 确定新数组的长度。 原数组的长度-重复元素个数
*/
import java.util.*;
class Demo12 {
public static void main(String[] args){
int[] arr = {11,2, 4, 2, 10, 11};
arr = clearRepeat(arr);
System.out.println("清除重复元素的数组："+ Arrays.toString(arr));
}
public static int[] clearRepeat(int[] arr){
//先计算出重复元素的格式:
int count = 0; //记录重复元素的个数
for(int i = 0 ; i < arr.length-1 ; i++){
for(int j = i+1 ; j<arr.length ; j++){
if(arr[i]==arr[j]){
count++;
break;
}
}
}
//新数组 的长度
int newLength = arr.length - count;
//创建一个新的数组
int[] newArr = new int[newLength];
int index = 0 ; //新数组的索引值
//遍历旧数组
for(int i = 0 ; i< arr.length ; i++){
int temp = arr[i]; //旧数组中的元素
boolean flag = false; //默认不是重复元素
//拿着旧数组 的元素 与新数组的每个元素比较一次。
for(int j = 0 ; j< newArr.length ; j++){
if(temp==newArr[j]){
flag = true;
break;
}
}
if(flag == false){
newArr[index++] = temp;
}
}
return newArr;
}
}
class User{
String userName;
String password;
}
class Demo13
{
public static void main(String[] args)
{
Scanner scanner = new Scanner(System.in);
User[] users = new User[10];
while(true){
System.out.println("请选择功能 : A(注册) B(查看用户)");
String option = scanner.next();
if(option.equals("A")){
System.out.println("请输入用户名:");
String userName = scanner.next();
System.out.println("请输入密码:");
String password = scanner.next();
}else if(option.equals("B")){
}
}
}
}
本文出自 “小鱼的博客” 博客，谢绝转载！