大数据入门：day04

程序员文章站 2022-03-09 20:12:45

...

关于循环

总结：
- 1、for:固定次数循环，应用率比较高
- 2、break：跳出循环
- continue：跳过循环体中的剩余语句而进入下一次循环
- 3、嵌套循环：
- （1）嵌套中的循环，一般多行多列的时候，外层控制行，内层控制列；
- （2）执行规则：外层循环走一次，内层走所有次
- （3）建议：循环层数越少越好，如果能用一层解决的不要用多层
- 如果说你写的程序使用到了3层以上循环，那么就考虑程序的设计是否有问题；
- （4）break只能跳出一层循环；
```
for(int i = 0;i < 10;i++){
	if(i % 2 == 0){
		continue;
	}
	System.out.println(i);
}
```
  for(int j = 0; j < 5; j++){
  if(j == 2){
  break;
  }
  System.out.println(j);
  }

关于猜数字：

1、导包
2、创建对象Random r = new Random();
3、获取随机数：int num = r.nextInt(100);
产生的数据在0-100之间，包括0，不包括100，

括号里面的100是可以变化的，如果是1000，就是0-1000里面的数据

import java.util.Random;
import java.util.Scanner;

public class RandomDemo {
public static void main(String[] args) {

	Random r = new Random();
	System.out.println("开始猜吧");

	int number = r.nextInt(100);
	//创建对象
	Scanner sc = new Scanner(System.in);
	//接收数据---guess：猜的数字
	int guess = sc.nextInt();
	
	while(guess != number){
		if(guess>number){
			System.out.println("猜大了");
		}else{
			System.out.println("猜小了");
		}
		guess = sc.nextInt();
	}

	if(guess==number){
		System.out.println("猜对了");
	}
	sc.close();
  }

 }

数组

1、数组概念：存储同一种数据类型多个元素的容器；
数组既可以存储基本数据类型；也可以存储引用数据类型；
2、数组的定义格式：
格式1：数组类型[]数组名;
格式2：数组类型数组名[];
3、初始化
动态初始化：在初始化的时候，只定义了数组的长度，通过系统来决定数组的初始化的值；

静态初始化：在初始化的时候，指定了每一个数组元素的初始化的值，由系统决定数组的长度。

public class hhxxxl {
public static void main(String[] args) {

	//声明一个数组；初始化
	int[] arr = new int[5];//第一种，比较常用
	int arr1[] = new int[5];//第二种，不推荐  	

	//数组的初始化
	int[] arr2 = new int[3];//动态初始化 0
	int[] arr3 = new int[]{1,3,5,7};//静态初始化
	int[] arr4 = {1,3,3,5,6};//简化形式  	

	System.out.println(arr2[2]);//0
	System.out.println(arr3[1]);//3 	

	int[] arr5;
	//arr5 = {1,3,2};  错误的写法
	arr5 = new int[]{1,3,2}; //对的
	System.out.println(arr.length);

		//数组遍历
		for( int i = 0; i < arr.length; i++){
			System.out.println(arr[i]);

		}

	  }

	}

2、数组的存储形式

栈：
存储的是局部变量；
局部变量就是定义在方法体中的变量；
使用完毕后，会立即释放。
堆：
存储的是new出来的对象：
每一个对象都是有地址值的；
每一个对象都是有默认值的。
byte; short; int; long 0;
float; double; 0.0
char ‘\u0000’
boolean false
引用数据类型 null
使用完毕后空间，由垃圾回收器在空闲时回收

NullPointerException空指针异常
public class ArrayDemo {
public static void main(String[] args) {

	System.out.println("程序开始执行！");
try {
		int[] arr = {1,2,3};
		arr = null;//空指针，变为垃圾
		System.out.println(arr[1]);
		
		System.out.println(arr[3]);
	}catch(ArrayIndexOutOfBoundsException e){
		System.out.println("发生了数组下标越界");
	}catch (NullPointerException e){
		System.out.println("空指针异常");
	} catch (Exception e) {
		e.printStackTrace();
	}
	System.out.println("1234");
	System.out.println("程序结束执行……");

  }
}

练习

身份证的最后一位
import java.util.Scanner;

	public class idcard {
	public static void main(String[] args) {

	//用来存放用户输入的前17位
	int[] card = new int[17];
	//用来存放前17位对应的系数
	int[] data = {7,9,10,5,8,4,2,1,6,3,7,9,10,5,8,4,2};
	char[] code = {'1','0','x','9','8','7','6','5','4','3','2'};
	int sum = 0;
	
	Scanner sc = new Scanner(System.in);
	for(int i = 0; i < card.length; i++){
		System.out.println("请输入身份证的第" + i +"位");
		card[i] = sc.nextInt();
		
	}
	
	for(int i = 0; i < card.length; i++){
		sum += card[i]*data[i];
	}
	System.out.println("最后一位" +code [sum%11]);
	
	sc.close();
  }
}

数组复制

数组的复制：
Array.CopyOf(src, length)
jdk1.6版本提供的，使用的时候要注意在1.6版本及以上使用
2、System.arraycopy(src, srcPos,dest, destPos,length);
src：原数组
srcPos:原数组的开始的复制的位置
dest: 目标数组
destPos:目标数组的开始复制的位置
length:复制的长度

javaAPI提供的，底层是用c++写的，所以速度非常快，比for（）循环实现数组的拷贝效率要高，推荐使用
import java.util.Arrays;
public class ArrayDemo02 {
public static void main(String[] args) {

int[] arr = {5,2,3};
int[] arr2 = Arrays.copyOf(arr, arr.length );
int[] arr3 = new int[3];

//数组的输出，用Arrays.toString，这个输出值
//直接输出arr2,输出的是地址
System.out.println(Arrays.toString(arr));
System.out.println(Arrays.toString(arr2));
System.out.println("------");
//另一个复制的代码     原数组 开始 目标  开始  长度
System.arraycopy(arr,0,arr3,0,arr.length);
System.out.println(Arrays.toString(arr3));
System.out.println("-----");
//数组遍历 挨个输出数组内元素
for(int i = 0; i < arr2.length; i++){
	System.out.println(arr2[i]);
}

}
]

数组的扩展
import java.util.Arrays;
public class ArrayDemo03 {
public static void main(String[] args) {

char[] arr = {'北','京'};
//扩大容量，arr2复制arr,并扩大内存空间为4
char[] arr2 = Arrays.copyOf(arr,4);
//arr2和arr3共用内存空间
char[] arr3 = arr2;
arr3[2] = '达';
arr3[3] = '内';
System.out.println(arr3);
System.out.println(arr3 == arr2);
System.out.println(arr2[2]);
System.out.println(arr2[3]);

}
}

冒泡排序

数组的排序：冒泡排序
public class ArrayDemo04 {
public static void main(String[] args) {

//定义一个数组对象
int[] arr = {1,3,23,53,4,23,54};
//冒泡排序算法，n-1轮比较，得到最终的h
boolean isSorted;//优化
for(int i = 0; i < arr.length - 1; i++){
	isSorted = true;
	for(int j = 0; j < arr.length - 1; j++){
		
		if(arr[j] > arr[j + 1] ){
			int temp = arr[j];
			arr[j] = arr[j + 1];
			arr[j + 1] = temp;
			//没排好进这个
			isSorted = false;
			
		}
		
		System.out.println("第" +i +"轮：" +",arr[j]" + arr[j] );
		
	}
	System.out.println("轮"+ i);
	if(isSorted){
		break;
	}
}
	System.out.println("排序后的数组");
	for(int i = 0; i < arr.length; i++){
		System.out.println(arr[i]);
}

}
}

arr:2，6，1，4
第0轮：2.1.4.6
第1轮：1.2.4
第2轮：1.2

求数组中的最大值

  public class ArrayDemo01 {
  public static void main(String[] args) {
  	 
  	//1、产生一个数组
  	int arr[] = {17,5,64,25,45,3,5};
  	//2、取一个参考值
  	int max = arr[0];	
  	System.out.println("数组的元素包括：");
  	
  	for( int i = 0; i < arr.length; i++){
  		if(arr[i] > max){
  			max = arr[i];
  		}
  		System.out.println("max:" +max);
  	}

  }

}

方法

方法：（函数、过程）
1、概念
封装了一段特定的业务逻辑的功能
尽可能是独立的，让一个方法去干一件事；
方法可以重复去调用
优点：写方法可以减少代码重复，有利于代码后期维护，同时减少团队开发成本
2、语法结构
修饰词+返回值类型+方法名（参数列表）{
方法体：//具体的业务逻辑功能
return；//返回值
}
修饰词：public static（目前使用）
返回值类型：用于限定返回值的具体的类型
方法名：为了调用的时候，方便起的名字
参数列表:（数据类型+参数名，数据类型+参数名2……）
参数类型：用于限定传入的数据类型
参数名：用于接收调用方法时传入的数据的变量
3、方法的使用
1)明确方法是否有返回值
2）方法是否有参数列表
4、方法的调用
1）单独去调用：不建议
2）输出调用：有意义的，不太完善，因为可能需要对得到的数字进行处理
3）赋值调用：推荐使用
@author Administrator

public class BubbleSort {

public static void main(String[] args) {
	//求和
	int x = 5;
	int y = 8;
	int num = sum(x,y);
	int y1 = num / 10;
	System.out.println(num);
	
	double salary = getSalary();
	System.out.println(salary);
	
	String name = "pipi";
	sayHi(name,"东京");
}
//求和，有返回值有参数
public static int sum(int x, int y){
	return x + y;
}
//有返回值，无参数
public static double getSalary(){
	return 30000.0;
	//return；编译错误
	//return “123” ：编译错误，返回值类型必须进行匹配
}
//无返回值，有参数
public static void sayHi(String name,String address){//形参,void是无参
	System.out.println("大家好，我叫" +name);
	
}
//无返回值，无参数
public static void sayHi(){
	System.out.println("大家好，我叫佩奇");
  }
}

总结：
1、for:固定次数循环，应用率比较高
2、break：跳出循环
continue：跳过循环体中的剩余语句而进入下一次循环
3、嵌套循环：
（1）嵌套中的循环，一般多行多列的时候，外层控制行，内层控制列；
（2）执行规则：外层循环走一次，内层走所有次
（3）建议：循环层数越少越好，如果能用一层解决的不要用多层
如果说你写的程序使用到了3层以上循环，那么就考虑程序的设计是否有问题；
（4）break只能跳出一层循环；

public class Test {

public static void main(String[] args) {
	for(int j = 0; j < 5; j++){
		if(j == 2){
			break;
		}
		System.out.println(j);
	}
    
	for(int i = 0;i < 10;i++){
		if(i % 2 == 0){
			continue;
		}
		System.out.println(i);
	}
  }
}

练习：用方法从键盘录入学生姓名和成绩，进行排序

class StudentInfo{

private String name;

private int score;

public String getName() {

	return name;

}

public void setName(String name) {

	this.name = name;

}

public int getScore() {

	return score;

}

public void setScore(int score) {

	this.score = score;

}

public void sort(StudentInfo[] stu,int count)

{

	StudentInfo temp;

	for(int i=0;i<count;i++)

	{

		for(int j=0;j<count-i-1;j++)

		{

			if (stu[j].getScore()<stu[j+1].getScore()) 

			{

               temp=stu[j];

               stu[j]=stu[j+1];

               stu[j+1]=temp;

            }

		}

	}

}

public void print(StudentInfo[] stu,int count){

	for (int i=0; i<count;i++) {

		System.out.println(stu[i].getName()+" "+stu[i].getScore());

    }

}

}

另一个类;ScoreSort.java

package cn.tedu.day04;

import java.util.Scanner;

public class ScoreSort {

public static void main(String[] args){

	StudentInfo s=new StudentInfo();

	StudentInfo[] stu= new StudentInfo[20];

    Scanner sc= new Scanner(System.in);

    System.out.println("请输入学生个数：");

    int count=sc.nextInt();

    int num=0;

    while(num<count) {

    	System.out.println("请输入第"+(num+1)+"个学生的姓名和分数：");

        Scanner scan=new Scanner(System.in);

        String strLine=scan.nextLine();

        String[] strLineArr = strLine.split(" ");

        StudentInfo st = new StudentInfo();

        st.setName(strLineArr[0]);

        st.setScore(Integer.parseInt(strLineArr[1]));

        stu[num]=st;

        num++;

    }

	s.sort(stu,count);

	System.out.println("排序后的学生信息为:");

	s.print(stu,count);

}

}

大数据入门：day04

photoshop入门学习 PHP学习笔记之三数据库基本操作

Mysql入门基础数据库创建篇_MySQL

第4章数据处理-php数组的处理-郑阿奇_php入门_脚本之家

预警即预防：6大常见数据库安全漏洞

mongodb数据库入门之CURD简单操作示例

数据库产业商业模式大猜想

Linux系统入门学习：命令行创建一个MySQL数据库

TypeScript入门-基本数据类型

快速入门：使用Azure 数据 Studio进行连接和查询 Azure SQL 数据库

快速入门：连接和查询 PostgreSQL 使用 Azure 数据 Studio

大数据入门：day04

photoshop入门学习 PHP学习笔记之三 数据库基本操作

Mysql入门基础 数据库创建篇_MySQL

第4章 数据处理-php数组的处理-郑阿奇_php入门_脚本之家

预警即预防：6大常见数据库安全漏洞

mongodb数据库入门之CURD简单操作示例

数据库产业商业模式大猜想

Linux系统入门学习：命令行创建一个MySQL数据库

TypeScript入门-基本数据类型

快速入门：使用Azure 数据 Studio进行连接和查询 Azure SQL 数据库

快速入门：连接和查询 PostgreSQL 使用 Azure 数据 Studio

photoshop入门学习 PHP学习笔记之三数据库基本操作

Mysql入门基础数据库创建篇_MySQL

第4章数据处理-php数组的处理-郑阿奇_php入门_脚本之家