java中char数组怎么赋值 java定义char数组并赋值

转载

mob6454cc747bda 2024-04-15 12:46:43

文章标签 java中char数组怎么赋值数组 System i++ 文章分类 Java 后端开发

4.1普通数组

4.1.1数组表达方式: 数据类型[ ]

如：byte[]、short[]、int[]、long[]、float[]、double[]、char[]、String[]

4.1.2创建一维数组

格式1：(修饰符) 数据类型[] 数组名=new 数据类型[数组长度]; //修饰符可有可无

格式2：(修饰符) 数据类型[] 数组名; //修饰符可有可无

数组名=new 数据类型[数组长度];

4.1.3给数组赋值

格式1：用{ }赋值，这种一般直接用来创建数组并赋值

如：String[] s={“abc”,”def”,”hij”};

String[] s=new String[]{“abc”,”def”,”hij”} ;

格式2：用数组下边赋值，使用于有固定长度的数组

如：String[] s=new String[3];

s[0]=”abc”;

s[1]=”def”;

s[2]=”hij”;

格式3：用for循环赋值，使用于数据很多的数组

如：

int[] a=new int[5];

for(int i=0;i<a.length;i++){

    a[i]=i+10;

}

4.1.4读取数组数据

格式1：取指定位置数据 System.out.println(a[1]); //输出数组指定值

格式2：for循环读取

int[] a=new int[100];

//循环输出数组所有值
for(int i=0;i<a.length;i++) { 
    System.out.println(a[i]);
}

//for each 遍历
for(int a1 ：a){
    System.out,println(a1);
}

用Arrays.toString(数组名)读取数据

如：System.out.println(Arrays.toString(a)) //输出数组a的所有值

4.1.5数组复制

方法一：newArr=arr; //将旧数组直接=新数组

方法二：newArr=Arrays.copyOf(arr,newArr.length);

//使用Arrays的copyOf方法,新数组=Arrays.copyOf(旧数组，复制数组长度);

方法三：System.arraycopy(arr,0,newArr,0,newArr.length);

//使用System的arraycopy方法，参数(旧数组，旧数组开始位置，新数组，新数组开始位置，复制数组的长度);

4.1.6数组排序的几种方法

(1)利用arrays.sort(数组名)升序排列

import java.util.Arrays;
import java.util.Scanner;

public class Sort{
    public static void main(String[] args){  
        Scanner s=new Scanner(System.in);
        int a[]=new int[5];
        for(int i=0;i<a.length;i++){   
            System.out.println("请输入第"+(i+1)+"个数字");
            //一个个输入数字
            a[i]=s.nextInt();                
        }
        //用Arrays.sort();对数组升序排列
        Arrays.sort(a);                      
        //用Arrays.toString()输出整个数组
        System.out.println(Arrays.toString(a)); 
    } 
}

(2)利用冒泡法排序

public class Maopao {
    public void m(int n){
        int[] a=new int[n];
        //输入数字
        Scanner s=new Scanner(System.in);                
        for(int i=0;i<a.length;i++){
            System.out.println("请输入第"+(i+1)+"个数字");
            //循环输入
            a[i]=s.nextInt();                           
        }
        //输出键盘输入的数组
        System.out.println(Arrays.toString(a));    
        //用冒泡法，每次选出最大值放在
        for(int j=0;j<a.length-1;j++){  
            //length-i的位置
            for(int i=0;i<a.length-j-1;i++){ 
                if(a[i]>a[i+1]){
                    int c=a[i];
                    a[i]=a[i+1];
                    a[i+1]=c;
                }
            }
        }
        System.out.println(Arrays.toString(a));
    }

    public static void main(String[] args) {
        Maopao mp=new Maopao();
        mp.m(5);
    }

}

//原始冒泡法

public class FourBubbleSort{
    public static void main(String[] args){
        int[] arr4=new int[]{5,6,1,4,3,8,2,9,0,7};
        //从右到左依次确定arr4.length-1个位置，
        //第一次arr4.length-1次比较，第二次arr4.length-2次比较...
        for(int i=0;i<arr4.length-1;i++){
            for(int j=0;j<arr4.length-1-i;j++){
                if(arr4[j]>arr4[j+1]){
                    int temp=arr4[j];
                    arr4[j]=arr4[j+1];
                    arr4[j+1]=temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr4));
    }
}

(3)选择排序方法

public class ThreeSelectSort{
public static void main(String[] args){
int[] arr3=new int[]{2,6,1,3,7,0,8};
int index=0;
for(int i=0;i<arr3.length;i++){
index=i;
//循环找最小值下标
for(int j=i+1;j<arr3.length;j++){
if(arr3[index]>arr3[j]){
index=j;    //将最小值下标记录下来
}
}
//每次记录下来的最小值放到当前i的位置（i=0，最小值；i=1，次小值...）
int temp=arr3[index];
arr3[index]=arr3[i];
arr3[i]=temp;
}
System.out.println(Arrays.toString(arr3));
}
}

(4)插入排序方法

public class Charu{
public void c(){
int[] a=new int[]{5,6,3,7,9,1,5};
for(int i=1;i<a.length;i++){       //从a[1]开始和前面的比较
int x=a[i];                    //将a[i]给x
int j;
for(j=i-1;j>=0&&a[j]>x;j--){  //从a[0]开始，比较a[0]>a[1]
a[j+1]=a[j];              //成立则将a[1]=a[0];
}
a[j+1]=x;     //不成立将x赋值给本身a[j+1],但执行一次成立后，j--
}                //就是将a[j-1+1]=x;（这时，x是a[j+2]）
System.out.println(Arrays.toString(a));
}
public static void main(String[] args) {
Charu cr=new Charu();
cr.c();
}
}

(5)插入指定数值排序法

public class TwoInsertSort{
public static void main(String[] args){
int[] arr2=new int[]{2,3,5,8,9,15};
int insert=10; //要插入的数值
for(int i=0;i<arr2.length;i++){
if(arr2[i]>insert){
//将插入的值插入到指定位置，将后面的值后移，最后一个丢失
for(int j=i;j<arr2.length;j++){
int c=arr2[j];
arr2[j]=insert;
insert=c;
}
break;  //插入数值，排好后面的数值后，结束循环
}else{
//如果数组中没有比插入的数值大，则将插入的值放到最后
arr2[arr2.length-1]=insert;
}
}
System.out.println(Arrays.toString(arr2));
}
}

(6)双层for循环取最小值法

import java.util.Arrays;
public class Xuanze {
/**双层for循环取最小值法
 * @param args
 */
public void x(){
int[] a=new int[]{5,6,1,3,7,0,9};
for(int i=0;i<a.length-1;i++){  //从0开始拿a[i]与a[i+1]比较,直到
                                         //a[a.length-2]
for(int j=i+1;j<a.length;j++){ // i=[0,5]  j=[1,6]  所以i和j的范
                                          //围一样
if(a[i]>a[j]){          //当a[i]>a[i+1]时，将他们调换过来
int c=a[i];
a[i]=a[j];
a[j]=c;
}                       //当a[i+1]>a[i]时，继续比较a[i]和a[i+2]
}
}
for(int i=0;i<a.length;i++){
System.out.println(a[i]);
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Xuanze xz=new Xuanze();
xz.x();
}}

4.1.7数组的增、删、反转、查

(1)插入数值

//1、将一个数直接插入一个数组并排序
import java.util.*;
public class A5_ExerciseOneInsertValue{
public static void main(String[] args){
Scanner enter=new Scanner(System.in);
int[] arr=new int[]{5,6,7,2,1,4,20,0,3,15,12,9,10};
System.out.println("请输入要插入数组的值：");
int insert=enter.nextInt();
//将原来的数组进行排序
for(int i=0;i<arr.length;i++){
for(int j=i+1;j<arr.length;j++){
if(arr[i]>arr[j]){
int temp1=arr[i];
arr[i]=arr[j];
arr[j]=temp1;
}
}
}
System.out.println(Arrays.toString(arr));
//将插入的数值放到相应的位置
for(int i=0;i<arr.length;i++){
if(arr[i]>insert){
for(int j=i;j<arr.length;j++){
int temp2=arr[j];
arr[j]=insert;
insert=temp2;
}
break;
}
}
System.out.println(Arrays.toString(arr));
}
}
//2、输入插入数值，并指定插入的位置
public class A5_ExerciseOneInsertValueAndIndex{
public static void main(String[] args){
int[] arr=new int[]{5,6,2,7,1,3,9};   //原始数组
int[] newArr=new int[arr.length+1];  //新数组，比原始数组长度大1
Scanner enter=new Scanner(System.in);
System.out.println("当前数组为："+Arrays.toString(arr));
//用户输入要插入的数值
System.out.println("请输入要插入的数值：");
int insert=enter.nextInt();
//用户输入要插入数值的位置
System.out.println("请输入插入的数值的位置(0-6之间)：");
int insertPosition=enter.nextInt();
//获取原始数组最后一个元素
int lastValue=arr[arr.length-1];
//从插入数值的位置开始，后面的元素依次往后移，
//原始数组最后元素一个丢失，需要在新数组补上
while(insertPosition<arr.length){
int temp=arr[insertPosition];
arr[insertPosition]=insert;
insert=temp;
insertPosition++;
}
//将原始数组元素装到新数组（缺最后一个）
for(int i=0;i<arr.length;i++){
newArr[i]=arr[i];
}
//补上最后一个元素
newArr[newArr.length-1]=lastValue;
System.out.println("插入数值后数组为："+Arrays.toString(newArr));
}
}

(2)删除数值

//3、将数组中的一个元素，从数组中删除指定的数值
import java.util.*;
public class A5_ExerciseThreeRemoveValue{
public static void main(String[] args){
Scanner enter=new Scanner(System.in);
int[] arr=new int[]{2,6,2,0,3,8,9,10};
int delect=0;
int delect_count=0;
System.out.println("==================================");
System.out.println("原始的数组arr：");
System.out.println(Arrays.toString(arr));
System.out.println("==================================");
System.out.println("请输入你要删除的具体元素：");
//删除指定的元素
delect=enter.nextInt();
//逐个判断要删除的数跟数组是否一样，一样的就删除
for(int i=0;i<arr.length;i++){
if((delect==arr[i])){
delect_count++;
for(int j=i;j<arr.length-1;j++){
arr[j]=arr[j+1];
}
}
}
//将最后一个数值赋值为0
arr[arr.length-1]=0;
//将删除指定数值的数组赋值给新数组
int[] newArr=new int[arr.length-delect_count];
for(int j=0;j<newArr.length;j++){
newArr[j]=arr[j];
}
System.out.println("删除指定数值后的数组newArr：");
System.out.println(Arrays.toString(newArr));
}
}

(3)数组反转

//4、将一个数组反转，并输出
import java.util.*;
public class A5_ExerciseFiveInvert{
public static void main (String[] args){
int[] arr=new int[]{2,6,1,0,3,8,9,10};
System.out.println("---------------原始数组--------------");
System.out.println(Arrays.toString(arr));
//将数组分成两边，左右两边对应的每个数值分别交换
for(int j=0,k=arr.length-1;j<arr.length/2;j++,k--){
int temp=arr[j];
arr[j]=arr[k];
arr[k]=temp;
}
System.out.println("---------------反转后数组--------------");
System.out.println(Arrays.toString(arr));
}
}

(4)数组数据查询

//5、一个char数组中有多少个符号，多少个字母，多少个数字
import java.util.*;
public class A5_ExerciseFourCharDetails{
public static void main(String[] args){
char[] character=new char[]{'a','b','c','5','9','0','1','~','*','男'};
int symbol_count=0;  //符号个数
int number_count=0;  //数字个数
int letter_count=0;  //字母个数
for(int i=0;i<character.length;i++){
//判断该字符数组的元素在哪个区间，从而分开计算符号、数字、字母的个数
if((character[i]>='0')&&(character[i]<='9')){
number_count++;
}else if((character[i]>='A'&&character[i]<='Z')||(character[i]>='a'&character[i]<='z')){
letter_count++;
}else{
symbol_count++;
}
}
System.out.println("该字符数组为："+Arrays.toString(character));
System.out.println("该字符数组中符号个数为："+symbol_count);
System.out.println("该字符数组中数字个数为："+number_count);
System.out.println("该字符数组中字母个数为："+letter_count);
}
}

数组的合并

//6、将两个数组合并一个数组，并且排序
import java.util.*;
public class A5_ExerciseTwoCombineArray{
public static void main(String[] args){
int[] arr1=new int[]{9,6,8,1,5};
int[] arr2=new int[]{0,2,10,3,4};
int arrayLength=arr1.length+arr2.length;
int[] arr3=new int[arrayLength];
//数组合并
for(int i=0;i<arr3.length;i++){
if(i<arr1.length){
arr3[i]=arr1[i];
}else{
arr3[i]=arr2[i-arr1.length];
}
}
System.out.println(Arrays.toString(arr3));
//合并后数组排序
for(int k=0;k<arr3.length-1;k++){
for(int m=k+1;m<arr3.length;m++){
if(arr3[k]>arr3[m]){
int temp=arr3[k];
arr3[k]=arr3[m];
arr3[m]=temp;
}
}
}
System.out.println(Arrays.toString(arr3));
}
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。