【JAVA01】(基础概念、数据类型、运算符、程序结构、变量和方法、数组）

已于 2023-07-19 21:41:34 修改
阅读量230 收藏
点赞数
分类专栏： JAVA预习 文章标签： java jvm 开发语言 学习
于 2023-04-12 10:11:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51947647/article/details/130086388
版权

2023.04.11-05.12学习笔记

基本语法

  1. 类名首字母大写，遵循驼峰命名法，如Userlnfo
  2. 方法名首字母小写，变量首字母小写，后面遵循驼峰命名法
  3. 源文件名必须和类名相同，后缀是.java，编译后文件后缀是.class
  4. 主方法入口，所有的java程序由public static void main(String []args)方法开始执行。

Java标识符

  1. 由26个英文字母大小写、数字（0-9）、符号（_和$）组成
  2. 标识符不能以数字开头
  3. 标识符不能是关键字（如class）

JDK JRE JVM

JDK（Java开发工具包）是整个Java的核心，包括了Java运行环境，基本组件（Javac/java/jdb)和Java基础的类库

JRE(java 运行环境）没有任何开发工具，包括JVM虚拟机和Java核心类库
** JVM** （Java虚拟机）因为Java语言使用JVM屏蔽了具体平台相关的信息，所以可以一次编译，多处运行
IDE开发工具——javac编译器——JVM——操作系统

                .java                  .class       汇编指令

只有jvm可以运行代码吗？
不行，运行代码还需要运行时依赖的java类库的支持

JVM加载.class字节码文件的步骤

第一阶段是找到.class文件并把这个文件包含的字节码加载到内存中。 第二阶段又可以分为三个步骤，分别是字节码验证、Class类数据结构分析及相应的内存分配和最后的符号表的链接。 第三阶段是类中静态属性和初始化赋值，以及静态块的执行。

main / 扫描器

import  java.until.Scanner
public  class Test {
// alt + /  智能提示
       public static void main (String[] args){
               System.out.println("aaaaa");
               //println 输出完内容会加一个换行
               System.out.print("bbbbb");
               //输入
               //创建了一个扫描器
               //使用别人写的类型，需要导包
               Scanner sc = new Scanner(System.in);
           // 开始扫信息
         String s =  scanner.next();
         String s2 = scanner.next();
         System.out.println(s);
           
       }
}

import  java.until.Scanner
public  class Test {
// alt + /  智能提示
       public static void main (String[] args){
       //创建扫描器
       Scanner sc = new Scanner(String.in);
       System.out.println("请输入第一个数字“）;
       //把扫到的第一个数字放入a变量中
       int a = sc.nextInt();
       System.out.println("请输入第二个数字“）;
       int b = sc.nextInt();
       //打印结果
       System.out.println(a+b);
       }
 }

数据类型

变量

用于在内存中保存数据。可以在同一类型范围内不断变化。
变量类型、变量名、存储值。
先声明，再赋值，再使用
注意变量的作业域

String a =  ABC

变量的类型

  1. 基本数据类型（八种）
    在这里插入图片描述

** byte**
以8位二进制存储。有正负号。最小值-128，最大值127。
** short**
以16位二进制存储。有正负号。最小值-2^15
最大值2^15 -1。
** int **
以32位二进制存储。有正负号。最小值-2^31，
最大值2^31-1。

** long **
以64位二进制存储。有正负号。最小值-2^63，
最大值2^63-1。

long  l1 = 20L

bit 、byte 与字节（Byte)的关系

在这里插入图片描述
** float**
以科学计数法方式存储 ,32位

float f1 =  2.2f;
float f1 =  2.2F;

** double**
以科学计数法方式存储 ，64位

== 单精度和双精度的概念与区别==
在这里插入图片描述
char
16进制，先编码再存储，可以存储任何字符。

char c1 = 'a';

boolean
只有两个值，ture 和 false
== 默认值是false==

  1. 引用类型
    在这里插入图片描述

自动类型转换、强制类型转换

在这里插入图片描述

byte b3 = 5;
int i3 = b3 ;
//自动类型转换
int i4 = 5 ;
byte b4 = (byte)i4;//强制

*注意

在这里插入图片描述

数据类型在内存中的空间分配

在这里插入图片描述
在这里插入图片描述

装箱与拆箱

提供一种机制，使得基本数据类型可以与引用类型互相转换
在这里插入图片描述

Integer i7 = new Integer(20);

在这里插入图片描述

int i8 = 10;
Integer i9 = Integer.valueOf(i8);//使用valueOf包装
//装箱方法名valueOf
double d5 = 3.3;
Double d7 = Double.valueOf(d5);
//拆箱方法名  xxxValue()
int i10 = i9.intValue();//拆箱
double d8 = d7.doubleValue();

//jbk1.5 自动 只发生在javac阶段（编译）
Integer i92 = i8
int i93 = i92

运算符

分类：算术运算符、比较运算符、逻辑运算符、赋值运算符、位运算运算符、三目运算符

在这里插入图片描述

算术运算符

package day01;

public class Test01 {
	public static void main(String[] args) {
		int a = 10;
		
		int b = 2;
		
		System.out.println(a / b );//5
		System.out.println(a % b );//0
		
	}

}

在这里插入图片描述

a++和++a的区别

在这里插入图片描述
逻辑运算符

&&(并且）：两边都为真为真
在这里插入图片描述

比较运算符
比较完得到boolean类型

在这里插入图片描述
短路运算

例： 这里因为短路所以e没有++

在这里插入图片描述

在这里插入图片描述

赋值运算符

在这里插入图片描述

三目运算符
在这里插入图片描述

package day01;

public class Test01 {
	public static void main(String[] args) {
		int f = 10;
		
		int e = 2;
		
		//e>f是比较条件，条件为真。返回：前面的值，反之
		int g = e > f ? e : f;
		System.out.println(g);
	}

}

在这里插入图片描述

位运算符
在这里插入图片描述

在这里插入图片描述

// 0000 0101
// 0000 0011
		
// 0000 0001
		int h = 5;
		
		int i = 3;
		
		System.out.println(5&3);

代码结果是1

运算符的优先级

在这里插入图片描述

例题（重点）

package day01;

public class Test02 {
	public static void main(String[] args) {
		
		int a = 10;
		
		int b = 20;
		
		System.out.println(a==b);//结果是false
		
		
		Integer a1 = new Integer(10);
		Integer b1 = new Integer(10);
		// new 就是开一块堆空间
		//都是引用类型，所以==比较的a1与b1中保存的地址是否一样
		System.out.println(a1 == b1);//结果是false
		
		//引用类型与基本数据类型运算，引用类型会自动拆箱
		System.out.println(a1 == a);//结果是true
		// 默认为 -128 到127 byte范围
		Integer a2 = 10;
		
		Integer b2 = 10;
		
		Integer.valueOf(10)
		
		//valueOf 包装方法不一样
		// a2 与b2地址是一样的
		System.out.println(a2 == b2);//结果是true
		
		Integer a3 = 200;//当值不在范围内就另开空间
		Integer b3 = 200;
		System.out.println(a3 == b3);//结果是false
	}
}

程序结构

顺序结构

在这里插入图片描述

分支结构

在这里插入图片描述

else 、switch

package day01;

public class Test03 {
	public static void main(String[] args) {
		
		int i = 10;
		
		if(i > 10) {
		System.out.println("i的值 大于10");
		}
		
		
		else {
		System.out.println("i的值  不大于10");
		}
		
		System.out.println("if 结束了");
		System.out.println("main 继续");

		//else在不需要时可省略
		//{}省略默认{}内包着一条语句
		
		//多条件分支
		int w = 3;
		if ( w == 1) {
			System.out.println("星期一");
		} else if ( w == 2) {
			System.out.println("星期二");
		}else if ( w == 3) {
			System.out.println("星期三");
		}else if ( w == 4) {
			System.out.println("星期四");
		}else if ( w == 5) {
			System.out.println("星期五");
		}else if ( w == 6) {
			System.out.println("星期六");
		}else if ( w == 7) {
			System.out.println("星期天");
		}else  {
			System.out.println("w 值不对");
		}
		
		
		
		
		// switch() 中的变量支持的数据类型       break:结束判断
		//byte short char int
		//上面四个对应的包装类也支持
		//jdk1.7时 新增了对String 的支持
		//枚举
		
		switch(w) {
		case 1:
			System.out.println("星期一 ");
			break;
		case 2:
			System.out.println("星期二 ");
			break;
		case 3:
			System.out.println("星期三");
			break;
		case 4: 
			System.out.println("星期四 ");
			break;
		case 5: 
			System.out.println("星期五 ");
			break;
		case 6: 
			System.out.println("星期六 ");
			break;
		case 7: 
			System.out.println("星期日 ");
			break;
		default:
			System.out.println("w 值不对 ");
			break;
		}
		
		
		
		
	}

}

在这里插入图片描述

循环类型

在这里插入图片描述

while

package day01;

public class Test04 {
	//循环
	public static void main(String[] args) {
		
		int i = 1;
//		while( i <= 10 ) {
//			System.out.println(i++);
//		}
		while(true) {
			System.out.println(i++);
			if(i == 11) {
				break;//手动结束循环
			}
		}
		
		// do while
		do {
			System.out.println(i++);
			if(i == 11) {
				break;//手动结束循环
			}
		} while(true);
		
			// do while 至少会执行一次
	}

}

for 循环

package day01;

public class Test05 {
	public static void main(String[] args) {
		
		//()中有三段内容 用;隔开
		// 1. 一般用来初始化一个或者多个值
		// 2.条件
		// 3.步长（修改影响条件的变化）
		
		for( int i = 1; i < 11; i++) {
			System.out.println(i);
			
		}
		
		// 省略第一段
		int i = 1; // 变量作用域不同
//		for( ; i < 11; i++) { // 注意不要忘记";"
			
//			System.out.println(i);
			
//		}
//		System.out.println(i);
		
		
		//省略
		for( ; ; ) {
			System.out.println(i);
			i++;
			if ( i == 11)
				break;
			
		}//System.out.println(i);
		
		
	}

package day01;

public class Test06 {
	public static void main(String[] args) {
		
//		for (int i = 1; i < 11; i++) {
//			if (i == 5) {
//				continue;//当次循环结束，进入第三段
//			}
			
//			System.out.println(i);
			
//		}
		
		
		
		// 嵌套for循环
		
		for(int i = 0; i < 3;i++) {
			
			for (int j = 0; j < 5; j++) {
				
				System.out.println(j);
			}
			
			
			
		}
		
		// *****
		// *****
		// *****
		// *****
		// *****
		
		for (int i = 0; i < 5;i++) {
			
			for(int j =0 ;j < 5;j++) {
				
				
				
				System.out.print("*");
				
			}
			System.out.println();
		}
	}

}

在这里插入图片描述

练习题

在这里插入图片描述

package day01;

public class Test07 {
	public static void main(String[] args) {
		
		
		for (int i = 0;i < 3; i++) {
			
			
			
			
			
//			for (int j = 1; j <= 3; j++) {
	//			for (int a = 1; ;) {
		//			a = 1 + (j - 1) * 2;
			//	
				//}System.out.print("*");
				
				
				
			}System.out.println(" ");
		}
		
		
	}



}

答案

package day01;

public class Test07 {
	public static void main(String[] args) {
		
		
		
		//等腰三角形
		for(int i = 1; i <= 3; i++) {
			//输出空格
			for(int k =5 ; k>i; k--) {
				System.out.print(" ");
			}
			//打印*号
			for(int j =1; j<=2*i-1; j++) {
				System.out.print("*");
			}
			//换行
			System.out.println();
		}

		
	}
}

在这里插入图片描述

package day01;

public class Test07 {
	public static void main(String[] args) {
		
		
		for (int i = 1;i <= 9; i++) {
			
			for (int j = 1; j <= i; j++ ) {
				//int c=j * i;
				
				System.out.print(i + "*" + j + "=" + (i*j) + "\t");
			}
			System.out.print(" "  );
			
			System.out.println( );	
		}
		
		
		
	



      }
}

在这里插入图片描述

package day01;

public class Test07 {
	public static void main(String[] args) {
	
		double sum = 0;
		int day = 0;
		while (true) {
			day++;
			
			sum += 5;
			if(sum >= 56.7) {
				
				break;
			}
			
			sum -= 3.5;
			
		}System.out.println(day);
			
			
	}	
}

在这里插入图片描述

变量和方法

变量

成员变量、局部变量。

自定义方法

{} 内是方法体。

在这里插入图片描述

调用方法

在这里插入图片描述

package day01;

public class Teat08 {
	public static void test1() {
		System.out.println("Hello");
		System.out.println("Hello");
		System.out.println("Hello");
	}
	public static void main(String[] args) {
		
		test1();//方法调用
		System.out.println("test1结束了");
	}
		
	

}

带参方法

需要提供a

在这里插入图片描述

package day01;

public class Teat08 {
	public static void test1() {
		System.out.println("Hello");
		System.out.println("Hello");
		System.out.println("Hello");
	}
	
	public static void add(int a,int b) {
		System.out.println(a+b);
		
	}
	public static void main(String[] args) {
		
		test1();//方法调用
		System.out.println("test1结束了");
		add(3, 5);
	}
		
	

}

形参与实参

在这里插入图片描述

返回值

上面的8是 a+b
下面的8是c
在这里插入图片描述

** 无返回值方法**
在这里插入图片描述

有返回值方法

在这里插入图片描述

值传递与引用传递

值传递

package day01;

public class Test09 {
	//形参名 无所谓
	public static void t1(int b) {
		b = 5;
	}
	
	public static void main(String[] args) {
		
		int a = 10;
		t1(a); //基本数据类型传递是把真实的值传递
		System.out.println(a);// 10
	}

}


package day01;

public class Test09 {
	//形参名 无所谓
	public static void t1(int b) {
		b = 5;
	}
	
	public static void main(String[] args) {
		
		int a = 10;
		t1(a); //基本数据类型传递是把真实的值传递
		System.out.println(a);// 10
		// 造一个学生
		Student stu = new Student();
		stu.no = "20230001";
		stu.name = "张三";
		stu.age = 20;
		System.out.println(stu.name);
		t2(stu); // 引用类型是把地址传到方法里
		System.out.println(stu.name);
		
	}
public static void t2(Student a) { //形参名无所谓
		
		a.name =  "李四";

}
}

在这里插入图片描述

package day01;

public class Test09 {
	//形参名 无所谓
	public static void t1(int b) {
		b = 5;
	}
	
	public static void main(String[] args) {
		
		int a = 10;
		t1(a); //基本数据类型传递是把真实的值传递
		System.out.println(a);// 10
		// 造一个学生
		Student stu = new Student();
		stu.no = "20230001";
		stu.name = "张三";
		stu.age = 20;
		System.out.println(stu.name);
		t3(stu); // 引用类型是把地址传到方法里
		System.out.println(stu.name);
		
	}
     public static void t2(Student a) { //形参名无所谓
		
		a.name =  "李四";

}
     public static void t3(Student b) {
    	 b = new Student();
    	 
    	 b.name = "李四";
       }

    

}

在这里插入图片描述

方法重载

在这里插入图片描述

重载就是重载的参数列表

重载与重写的区别

方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行时的多态性。重载发生在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同或者二者都不同）则视为重载；重写发生在子类与父类之间，重写要求子类被重写方法与父类被重写方法有相同的参数列表，有兼容的返回类型，比父类被重写方法更好访问，不能比父类被重写方法声明更多的异常（里氏代换原则）。重载对返回类型没有特殊的要求，不能根据返回类型进行区分。

原文链接：https://blog.csdn.net/wintershii/article/details/80558739

package day01;

public class Test10 {
	public  static int add(int a, int b) {
		return a + b;
	}
	
	public static double add(double a, double b) {
		return a + b;
	}
	
	public void t1(int a, String b) {
		
	}
	
	
	public void t1( String d,int c) {
		
	}
	

	public static  int add(int c, int d,int e) {
		return c + d ;
	}
	public static void main(String[] args) {
		add(3,5);
	}
}

数组

是引用类型。存储固定数量的同类型元素的一种数据结构。

package day01;

public class Test11 {

	public static void main(String[] args) {
		
		//第一种 声明的同时 赋值
		int[] array1 = { 1, 2, 3, 4, 5 };
		
		//
		int[] array2 = new int[] { 1, 2, 3, 4, 5 };
		
		//第二种 
		int[] array4 = new int[8];
		
		String[] array5 = new String[3]; // null null null
		
		// 中括号中的值为下标值：0表示第一个。。。5表示第六个
		array4[0] = 1;
		
		test1(array4);
	}
	public static void test1(int[] array) {
		
		// length属性获取长度
		System.out.println(array.length);
	}
}

访问数组元素

在这里插入图片描述

遍历数组

for

可以知道是第几次循环
在这里插入图片描述

for each

在这里插入图片描述

排序算法

在这里插入图片描述

冒泡排序

在这里插入图片描述

int[] array6 = { 3, 20, 6, 2, 18, 44, 68} ;
		
		for (int i = 0; i < array6.length - 1; i++) { //定义冒几轮
			
			
			// 循环体中是控制一轮的过程
			
			for (int j = 1; j < array6.length  - i; j++ ) {
				if (array6[j] > array6[j + 1]) {
					
					int temp =  array6[j];
					array6[j] = array6[j + 1];
					array6[j + 1] = temp;
				}
				
				
			}
			// 冒完一轮打印一次
		System.out.println(Arrays.toString(array6));
		}

在这里插入图片描述

选择排序

在这里插入图片描述

代码

在这里插入图片描述

插入排序

在这里插入图片描述

在这里插入图片描述

数组元素查找

顺序查找

在这里插入图片描述

二分查找

前提：顺序排好
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

可变长参数

在这里插入图片描述


      public static void main (String[] ards) {
    	  
    	 int sum =  add();
    	 System.out.println(sum);
      }
      
      // 给整数相加
      public static int add(int ... a) {
    	  int sum = 0;
    	  for(int temp : a) {
    		  sum += temp;
    	  }
    	  return sum;
      }

在这里插入图片描述

Arrays工具类

在这里插入图片描述
** 数组赋值**

public static void main (String[] ards) {
    	  
    	 int sum =  add(3);
    	 System.out.println(sum);
    	 
    	 int[] arr = {4, 3, 5, 2, 3, 6 };
    	// Arrays.fill(arr, 0);
    	 
    	 Arrays.fill(arr,2,4,0);//2，4是下标值，  
    	 System.out.println(Arrays.toString(arr));
    	 
      }

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

例题

在这里插入图片描述

package day02;

public class Test13 {
	public static void main(String[] args) {
		
		System.out.println(t1(8));
		}
		
	public static int t1(int a) {
		if(a == 1) {
			return 1;
		}
		
		return a * t1(a - 1);
		
	}		
			
		}

在这里插入图片描述

多维数组

在这里插入图片描述

public static void t2() {
		
		int [] [] arr = new int[3][];
		
		//二维数组里的一维
		int[] [] arr2 = { { 1, 2 }, { 3, 4 }, {5, 6, 7} };
		
	
	
	
	}

package day02;

public class Test13 {
	public static void main(String[] args) {
		
		System.out.println(t1(8));
		t2(); //调用方法
		}
		
	public static int t1(int a) {
		if(a == 1) {
			return 1;
		}
		
		return a * t1(a - 1);
		
	}		
	
	public static void t2() {
		
		
		
		//二维数组里的一维
		int[][] arr2 = { { 1, 2 }, { 3, 4 }, {5, 6, 7} };
		
	
		int [][] arr = new int[3][];  //先创建完再赋值
		
		arr[0] = new int[] { 1, 2};
		arr[1] = new int[] { 3, 4 };
		arr[2] = new int[] { 5, 6, 7};
		System.out.println(arr[0][0]);
		
		
	
					
	}
	
			
		}

在这里插入图片描述

注:

在 int [][] arr = new int[3][]; 中，数组里面是空的，但是数组为引用类型，所以是null。

package day02;

public class Test13 {
	public static void main(String[] args) {
		
		System.out.println(t1(8));
		t2();
		}
		
	public static int t1(int a) {
		if(a == 1) {
			return 1;
		}
		
		return a * t1(a - 1);
		
	}		
	
	public static void t2() {
		
		
		
		//二维数组里的一维
		int[][] arr2 = { { 1, 2 }, { 3, 4 }, {5, 6, 7} };
		
	
		int [][] arr = new int[3][];  //先创建完再赋值
		
//		arr[0] = new int[] { 1, 2};
//		arr[1] = new int[] { 3, 4 };
//		arr[2] = new int[] { 5, 6, 7};
		System.out.println(arr[0][0]);
		
		
	
					
	}
	
			
		}

在这里插入图片描述

int[] arr3 = new int[5];
		System.out.println(arr3[0]);

上面的代码输出为0，因为二维数组中的一维数组是引用类型，但是上面代码只是类型为int的一维数组。


		//表示在这个二维数组中，有三个一维数组并且每个一维都是4个长度
		// 必须固定二维数组的长度
		int [][]  arr4 = new int [3][4];
		
		arr4[0][0] = 1;
		
		System.out.println(arr4[0][1]);

** 二维数组遍历**
在这里插入图片描述

package day02;

import java.util.Arrays;

public class Test13 {
	public static void main(String[] args) {
		
//		System.out.println(t1(8));
		t2();
		int[] arr2 = { 1, 2, 3};
		t3(arr2);
		System.out.println(Arrays.toString(arr2));
		}
		
	public static int t1(int a) {
		if(a == 1) {
			return 1;
		}
		
		return a * t1(a - 1);
		
	}		
	
	public static void t2() {
		
		
		
		//二维数组里的一维
//		int[][] arr2 = { { 1, 2 }, { 3, 4 }, {5, 6, 7} };
		
	
//		int [][] arr = new int[3][];  //先创建完再赋值
		
//		arr[0] = new int[] { 1, 2};
//		arr[1] = new int[] { 3, 4 };
//		arr[2] = new int[] { 5, 6, 7};
//		System.out.println(arr[0][0]);
		
		int[] arr3 = new int[5];
		System.out.println(arr3[0]);
		
		
		//表示在这个二维数组中，有三个一维数组并且每个一维都是4个长度
		// 必须固定二维数组的长度
		int [][]  arr4 = new int [3][4];
		
		arr4[0][0] = 1;
		
		System.out.println(arr4[0][0]);
		
	
					
	}
	public static void t3(int[] arr) {
		arr[0] = 4;
		
		
	}
	
			
		}

在这里插入图片描述

数组是引用类型，所以在传递的时候传递的是地址。

数组例题

在这里插入图片描述

在这里插入图片描述

第一题

package day02;

import java.util.Arrays;




public class Test14 {
	public static void main (String[] args) {
		int[] source = {22, 68, 52, 12,8};
		t1(source);
		System.out.println(Arrays.toString(source));
	}
	public static void t1(int[] source) {
		for (int i = 0; i < source.length / 2 ; i++) {
			int t  ;
			t = source[source.length -1 -i];
			source[source.length -1 -i] = source[i];
			source[i] = t ;
			
		}
		
		
	}

}

参考：

public class RunoobTest {
 
    /* 创建方法，第一个与最后一个交互，第二个与倒数第二个交换，以此类推*/
    static void reverse(int a[], int n)
    {
        int i, k, t;
        for (i = 0; i < n / 2; i++) {
            t = a[i];
            a[i] = a[n - i - 1];
            a[n - i - 1] = t;
        }
 
        System.out.println("反转后的数组是: \n");
        for (k = 0; k < n; k++) {
            System.out.println(a[k]);
        }
    }
 
    public static void main(String[] args)
    {
        int [] arr = {10, 20, 30, 40, 50};
        reverse(arr, arr.length);
    }
}

import java.util.*;
 
public class RunoobTest {
 
    /* 使用 java.util.Arrays.asList(array) 方法*/
    static void reverse(Integer a[])
    {
        Collections.reverse(Arrays.asList(a));
        System.out.println(Arrays.asList(a));
    }
 
    public static void main(String[] args)
    {
        Integer [] arr = {10, 20, 30, 40, 50};
        reverse(arr);
    }
}

第二题

package day02;

public class Test15 {
	public static void main(String[] args) {
		int[ ] a = {1, 2, 4, 9, 3, 9, 5, 6,7};
		t1(a);
		//System.out.println();
				
	}
	public static void t1(int[] a) {
		int j =0;
		for(int i = 0;i < a.length; i++) {
			if (a[i] == 9) {
				
				j++;
				
			}
			
		}System.out.println(j);
	}

}

第五题

package day02;

public class Test16 {
	public static void main(String[] args) {
		int[] a = {1, 2, 3, 14, 5, 6, 7};
		t1(a);
	
	}
	public static void t1(int[] a) {
		int max=0;
		int t =0;
		for (int i = 0; i < a.length ; i++) {
			if(a[i] > max) {
				max = a[i] ;
				t = i;
	
			}
			
			
			
		}System.out.println(max);
		System.out.println(t);
		
	}

}

第六个

package day02;

import java.util.Arrays;

public class Test17 {
	public static void main(String[] args) {
		int [] a = {1, 2, 3, 4, 5, 6,7};
		t1(a);
		
			
	}
	public static void t1(int[] a) {
		
		
	//	int[] j  ;
	//	int[] o  ;
	
		int k=0,b=0,jnull=0,onull=0;
	
		
		
		for (int i = 0; i < a.length;i++) {
			if (a[i] % 2 == 0) {
			//	j [k] = a[i];
			//	k++;
				jnull++;
				
			} 	else if (a[i] % 2 != 0){
		//		o[b] = a[i];
		    //	b++;
		    	onull++;
				
			}
			
			
		}
		
		
	//	int [] j = new int[];
		
		if (jnull > onull) {
		int[]	o = new int [(a.length -1) /2 ];
		int[]	j = new int [a.length - o.length];
		for (int i = 0; i < a.length;i++) {
			if (a[i] % 2 == 0) {
				j[k] = a[i];
				k++;
		//		jnull++;
				
			} 	else if (a[i] % 2 != 0){
				o[b] = a[i];
		        	b++;
		 //   	onull++;
				
			}
			
			
		}
		
		System.out.println(Arrays.toString(j));
		System.out.println(Arrays.toString(o));		
		}
		if (jnull == onull) {
		int[]	j = new int [a.length /2 ];
		int[]	o = new int [a.length /2];
		for (int i = 0; i < a.length;i++) {
			if (a[i] % 2 == 0) {
				j[k] = a[i];
				k++;
		//		jnull++;
				
			} 	else if (a[i] % 2 != 0){
				o[b] = a[i];
		        	b++;
		 //   	onull++;
				
			}
			
			
		}
		
		System.out.println(Arrays.toString(j));
		System.out.println(Arrays.toString(o));	
		}
		else if (jnull < onull) {
			int[]	j = new int [(a.length -1) /2 ];
			int[]	o = new int [a.length - j.length];
			for (int i = 0; i < a.length;i++) {
				if (a[i] % 2 == 0) {
					j[k] = a[i];
					k++;
			//		jnull++;
					
				} 	else if (a[i] % 2 != 0){
					o[b] = a[i];
			        	b++;
			 //   	onull++;
					
				}
				
				
			}
			
			System.out.println(Arrays.toString(j));
			System.out.println(Arrays.toString(o));	
			
		}
		
		
		
	
	
		
			
			
	
		
				
		
		
		
			
		}
		
}
今天小迪敲代码了吗
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Java】基本类型和数组
m0_47390921的博客
03-24 106
基本数据类型与数组的介绍
JAVA基础语法(注释、常量、变量、数据类型、数据类型转换、运算符、流程控制、循环结构)
zzyuan1的博客
04-02 244
HelloWorld JAVA摘要
Java基础之数据类型与数组
qq_43869106的博客
03-14 373
简单介绍了Java中的数据类型和数组的概念和用法 适合Java初学者
Java 程序基础之数组类型
ihero的博客
07-05 90
这里注意到原来names[1]指向的字符串"XYZ"并没有改变，仅仅是将names[1]的引用从指向"XYZ"改成了指向"cat"，其结果是字符串"XYZ"再也无法通过names[1]访问到了。定义一个数组类型的变量，使用数组类型“类型[]”，例如，int[]。数组索引从0开始，例如，5 个元素的数组，索引范围是0~4。如果数组元素不是基本类型，而是一个引用类型，那么，修改数组元素会有哪些不同？可以修改数组中的某一个元素，使用赋值语句，例如，ns[1] = 79;注意数组是引用类型，并且数组大小不可变。
Java版数据结构基础篇——数组（1）
weixin_47166204的博客
07-16 101
本文介绍了Java中的数组。数组是一种引用数据类型,用于存储同类型数据。数组需要初始化才能使用,分为静态初始化和动态初始化两种。静态初始化是在定义数组时直接初始化元素,动态初始化是先定义再分配内存和初始化。直接打印数组变量只能打印地址,需要遍历元素才能打印内容。初始化数组后才能访问元素。动态初始化更灵活,可变化数组长度。数组广泛应用于存储同类型数据的场景,也可构建更复杂的数据结构。正确理解数组的声明、定义、初始化对于Java开发非常重要。
02_Java基础_（变量、运算符）_讲义cxf
02-15
理解并熟练运用变量和运算符是Java编程的基础，它们构成了程序的基本逻辑结构。在实际开发中，通过灵活运用这些知识，可以构建出复杂的算法和功能。阅读“02_Java基础_（变量、运算符）_讲义cxf.doc”文档，将深入...
Java实验项目A、Java结构化基础和数组编程
07-04
实验内容涉及了Java语言的核心概念，如数据类型（如整型、浮点型等）、常量（不可变值）、变量（存储数据的容器）、运算符（如算术、比较、逻辑等）以及表达式（结合变量和运算符的计算单元）。实验还强调了程序的...
实验项目A、Java结构化基础和数组编程
08-10
5. **语言基础**：理解并运用Java的数据类型（如整型、浮点型、字符型等）、常量、变量、运算符和表达式，是编写逻辑代码的基础。 6. **程序结构**：学习如何构建顺序结构、选择结构（if-else语句）和循环结构（for...
java程序设计-第3章-数据运算、流控制和数组
03-12
总的来说，这一章的学习涵盖了编程的基本构建块，包括数据类型的选择、变量和常量的声明、基本运算以及控制程序流程的方式，这些都是编写任何Java程序的基础。理解并熟练掌握这些概念，将有助于开发者写出高效、易于...
Java程序设计基础教程-期末试卷B卷.docx
12-16
本资源是 Java 程序设计基础教程的期末试卷 B 卷，涵盖了 Java 程序设计的基础知识点，包括变量、运算符、控制流程、方法、数组、类和对象、继承、多态、接口、异常处理等。 变量和数据类型 * 变量的声明和赋值 * ...
golang 接口
m0_70982551的博客
07-24 848
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 375
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 528
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
最新发布
訾博（ZiBo）的博客
07-27 458
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 339
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 361
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
学习笔记---java篇（0723）
m0_70630166的博客
07-23 823
java、数据类型、循环、选择等
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
PAP
07-26 165
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
c++ 智能指针shared_ptr与make_shared
Txwtech笛克特科
07-25 240
shared_ptr是C++11引入的一种智能指针，‌它允许多个shared_ptr实例共享同一个对象，‌通过引用计数来管理对象的生命周期。‌当最后一个持有对象的shared_ptr被销毁时，‌它会自动删除所指向的对象。‌这种智能指针主要用于解决资源管理问题，‌避免内存泄漏。make_shared是C++标准库中的一个函数，‌用于创建一个shared_ptr智能指针，‌它接受一个或多个参数来构造一个对象，‌并返回一个指向该对象的shared_ptr。类SerialModbus的成员指针。
Java入门基础教程：语言介绍、变量、数据类型、运算符和控制结构
在Java基础程序设计中，变量和数据类型是最基本的概念。Java语言中有八种基本数据类型：byte、short、int、long、float、double、boolean和char。Java语言还支持数组、集合等数据结构。Java语言的运算符、表达式和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值