JavaSEday06

一维数组

数组

数组Array：指的是能够存储一系列具有相同数据类型数据的集合
特点：
  数组一旦定义出来 长度不可变
  数组为每个元素提供角标 通过角标去访问元素
  数组中每个数据必须是相同的数据类型 但值可以重复
  数组 不是基本数据类型 而是引用数据类型的一种
  如果数组长度为n 那么元素角标从头到尾分别 0~n-1
  数组有默认初始化
  数组是在堆内存中存在的
  元素与元素之间 地址是连续的
   An=A1+(n-1)d; 每个元素空间 大小一样的
内存：
  寄存器(CPU)
  本地方法区(主要临时存储的是系统的相关可执行代码)
  方法区(主要临时存储的是应用程序的相关可执行代码)
   栈(主要用于运行函数) 栈中的数据 必须手动初始化 int a 调用a
  堆(离散存储结构 空间分配随机 主要用于存储Java中的对象),堆中的数据 有默认初始化 int a 调用a 0
  double 0.0 boolean false
  数组 本身就是对象

创建数组

数据类型[] 数组名=new 数据类型[长度]; 
int[] arr=new int[10];//0 0 0 0 0 0 0 0 0 0 0 
数据类型[] 数组名=new 数据类型[]{数据1,数据2,数据3,...,数据n};
int[] arr=new int[]{1,2,3,4,5,6};
//NullPointerException 空指针异常 
//主要是引用数据类型变量的值为null 要么无意间给了null 要么忘记初始化
//什么时候对象成为垃圾 当对象没有被任何引用变量所指向的时候
//JVM 垃圾回收器 垃圾是及时处理 还是等攒满了在处理
//其实有必要的话 也可以手动调用垃圾回收器
System.gc();

数组扩容

import java.util.Arrays;
public class ArrayCopy {//数组扩容
	public static void main(String[] args) {
		int[] a={1,2,3,4,5};
		a=copyOf(a, a.length*2);
		a=null;
//		a={0,1,2,3,4};
		a=new int[0];
		print(a);
		Arrays.toString(a);
	}
	public static int[] copyOf(int[] oldArr,int newLen){
		int[] newArr=new int[newLen];
		for(int i=0;i<Math.min(oldArr.length, newArr.length);i++){
			newArr[i]=oldArr[i];
		}
		return newArr;
	}
	public static void print(int[] a){
		if(a==null){
			System.out.println("Array is null!");
			return;
		}
		if(a.length==0){
			System.out.println("[]");
			return;
		}
		String s="[";//"[1,2,......0]"
		for(int i=0;i<a.length;i++){
			if(i==a.length-1){
				s=s+a[i]+"]";
			}else{
				s=s+a[i]+", ";
			}
		}
		System.out.println(s);
	}
}

冒泡排序

public static void bubbleSort(int[] a){
		for(int i=0;i<a.length-1;i++){
			for(int j=0;j<a.length-1-i;j++){
				if(a[j]>a[j+1]){
					a[j]=a[j]+a[j+1];
					a[j+1]=a[j]-a[j+1];
					a[j]=a[j]-a[j+1];
				}
			}
		}
		System.out.println(Arrays.toString(a));
	}

选择排序

public static void selectSort(int[] a) {
		for(int i=0;i<a.length-1;i++){
			for(int j=i+1;j<a.length;j++){
				if(a[i]>a[j]){
					a[i]=a[i]+a[j];
					a[j]=a[i]-a[j];
					a[i]=a[i]-a[j];
				}
			}
		}
		System.out.println(Arrays.toString(a));
	}

插入排序

public static void insertSort(int[] a) {
		int temp=0;
		for(int i=1;i<a.length;i++){
			int e=a[i];
			int j;
			for(j=i;j>0&&a[j-1]>e;j--){
				a[j]=a[j-1];
			}
			a[j]=e;
		}
		System.out.println(Arrays.toString(a));
	}

二分查找

import java.util.Arrays;
public class FindDemo {
	public static void main(String[] args) {
		int[] a={1,3,6,2,4,8,9,7,5};
		//最基本思路 从左到右遍历 O(n) 线性查找
		//二分查找 折半查找 前提数组是有序的
		System.out.println(binarySerach(a,1));
	}
	private static int binarySerach(int[] a, int k) {
		//先对数组进行排序
		Arrays.sort(a);
		//1 2 3 4 5 6 7 8 9
		int minIndex=0;
		int maxIndex=a.length-1;
		int midIndex=(minIndex+maxIndex)/2;
		while(a[midIndex]!=k){
			if(a[midIndex]<k){
				minIndex=midIndex+1;
			}
			if(a[midIndex]>k){
				maxIndex=midIndex-1;
			}
			midIndex=(minIndex+maxIndex)/2;
			if(minIndex>maxIndex){
				return -1;
			}
		}
		return midIndex;
	}
}

编程题

import java.util.Arrays;
import java.util.Scanner;
public class Demo6_1{
	public static void main(String[] args){
		//1.定义两个数组，存入数据的数组和存入数据次数的数组
		int[] numbers=new int[0];
		int[] counts=new int[0];
		//2.输入数据，直到输入0为止
		Scanner scanner=new Scanner(System.in);
		System.out.print("Enter the integers between 1 and 100:");
		while(true){
			int num=scanner.nextInt();
			if(num==0){
				break;
			}
			//3.判断num是否在numbers里面
			int index=isContains(numbers,num);
			if(index==-1){//不存在
				//3.1不存在 扩容 并存入
				numbers=Arrays.copyOf(numbers,numbers.length+1);
				numbers[numbers.length-1]=num;
				counts=Arrays.copyOf(counts,counts.length+1);
				counts[counts.length-1]=1;
			}else{//存在
				//3.2 存在 相应count++
				counts[index]++;
			}
		}
		for(int i=0;i<numbers.length;i++){
			System.out.printf("%d occurs %d %s\n",numbers[i],counts[i],counts[i]==1?"time":"times");			
		}
	}
	public static int isContains(int[] numbers,int num){
		for(int i=0;i<numbers.length;i++){
			if(numbers[i]==num){
				return i;
			}
		}
		return -1;
	}
}

import java.util.Arrays;
import java.util.Scanner;
public class Demo6_2{
	public static void main(String[] args){
		int[] numbers=new int[0];
		System.out.print("Enter numbers:");
		Scanner scanner=new Scanner(System.in);
		for(int i=1;i<=10;i++){
			int num=scanner.nextInt();
			if(isContains(numbers,num)==-1){
				numbers=Arrays.copyOf(numbers,numbers.length+1);
				numbers[numbers.length-1]=num;
			}
		}
		System.out.println(Arrays.toString(numbers));
	}
	public static int isContains(int[] numbers,int num){
		for(int i=0;i<numbers.length;i++){
			if(numbers[i]==num){
				return i;
			}
		}
		return -1;
	}
}

import java.util.Scanner;
public static void main(String[] args){
	//1.输入数据10
	double[] nums=new double[10];
	Scanner scanner=new Scanner(System.in);
	System.out.print("Enter ten numbers:")
	for(int i=0;i<nums.length;i++){
		nums[i]=scanner.nextDouble();
	}
	//2.计算标准差
		double deviation=deviation(nums);
		System.out.println(deviation);
	}
	private static double deviation(double[] nums) {
		// 计算平均值
		double mean=mean(nums);
		double sum=0.0;
		for(int i=0;i<nums.length;i++){
			sum=sum+Math.pow(nums[i]-mean, 2);
		}
		return Math.sqrt(sum/(nums.length-1));
	}
	private static double mean(double[] nums) {
		double sum=0;
		for(int i=0;i<nums.length;i++){
			sum+=nums[i];
		}
		return sum/nums.length;
	}
}

6.4

import java.util.Arrays;
import java.util.Scanner;
public class Demo6_4 {
	public static void main(String[] args) {
		//输入十个数
		Scanner scanner=new Scanner(System.in);
		int[] nums=new int[10];
		System.out.print("Enter ten numbers:");
		for(int i=0;i<nums.length;i++){
			nums[i]=scanner.nextInt();
		}
		reverse(nums);
		System.out.println(Arrays.toString(nums));
	}
	private static void reverse(int[] nums) {
		for(int i=0;i<nums.length/2;i++){
			nums[i]=nums[i]^nums[nums.length-1-i];
			nums[nums.length-1-i]=nums[i]^nums[nums.length-1-i];
			nums[i]=nums[i]^nums[nums.length-1-i];
		}
	}
}

import java.util.Scanner;
public class Demo6_5 {
	public static void main(String[] args) {
		Scanner scanner=new Scanner(System.in);
		System.out.print("Enter list:");
		int length=scanner.nextInt();
		int[] nums=new int[length];
		for(int i=0;i<nums.length;i++){
			nums[i]=scanner.nextInt();
		}
		if(isSortedByUpper(nums)){
			System.out.println("yes by upper");
		}else{
			System.out.println("no by upper");
		}
		if(isSortedByLower(nums)){
			System.out.println("yes by lower");
		}else{
			System.out.println("no by lower");
		}
	}
	private static boolean isSortedByLower(int[] nums) {
		for(int i=0;i<nums.length-1;i++){
			if(nums[i]<nums[i+1]){
				return false;
			}
		}
		return true;
	}
	private static boolean isSortedByUpper(int[] nums) {
		for(int i=0;i<nums.length-1;i++){
			if(nums[i]>nums[i+1]){
				return false;
			}
		}
		return true;
	}
}

import java.nio.file.Paths;
import java.util.Arrays;
import java.util.Scanner;
public class Demo6_6 {
	public static void main(String[] args) {
		Scanner scanner=new Scanner(System.in);
		System.out.print("Enter the number of balls to droop:");
		int ballsNumber=scanner.nextInt();
		System.out.print("Enter the number of slots in the bean machine:");
		int slotsNumber=scanner.nextInt();
		String[] paths=new String[ballsNumber];
		//避免null出现
		for(int i=0;i<paths.length;i++){
			paths[i]="";
		}
		for(int i=0;i<paths.length;i++){
			for(int j=1;j<=slotsNumber-1;j++){
				paths[i]+=(int)(Math.random()*2)==0?"L":"R";
			}
		}
		for(int i=0;i<paths.length;i++){
			System.out.println(paths[i]);
		}
		//定义槽子的数组
		int[] slots=new int[slotsNumber];
		//遍历路径 统计有几个R
		for(int i=0;i<paths.length;i++){
			int count=howManyR(paths[i]);
			slots[count]++;
		}
		System.out.println(Arrays.toString(slots));
		print(slots);
	}
	private static void print(int[] slots) {
		int max=getMax(slots);
		for(int i=0;i<max;i++){
			for(int j=0;j<slots.length;j++){
				if(max-i>slots[j]){
					System.out.print("| ");
				}else{
					System.out.print("|o");
				}
			}
			System.out.println("|");
		}
	}
	private static int getMax(int[] slots) {
		int max=0;
		for(int i=0;i<slots.length;i++){
			if(slots[i]>max){
				max=slots[i];
			}
		}
		return max;
	}
	private static int howManyR(String path) {
		int count=0;
		for(int i=0;i<path.length();i++){
			if(path.charAt(i)=='R'){
				count++;
			}
		}
		return count;
	}
}

public class Demo6_7 {
	public static void main(String[] args){
		//1.用一个布尔类型的数组模拟柜子的开关
		boolean[] box=new boolean[100];//默认为false->关闭
		//2.1-100个学生
		for(int i=1;i<=100;i++){
			for(int j=i-1;j<box.length;j+=i){
				box[j]=!box[j];
			}
		}
		for(int i=0;i<box.length;i++){
			System.out.print(box[i]==true?"开":"关");
			if(i%10==9){
				System.out.println();
			}
		}
	}
}

import java.util.Arrays;
import org.omg.Messaging.SyncScopeHelper;
public class Demo6_8 {
	public static void main(String[] args) {
		//定义一个花色数组
		String[] suits={"Spades","Heart","Clubs","Diamonds"};
		//定义一个点数数组
		String[] ranks={"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
		String[] result=new String[0];
		int count=0;
		while(result.length!=4){
			//随机一个角标
			int index=(int) (Math.random()*4);
			if(!isContains(result,suits[index])){
				result=Arrays.copyOf(result, result.length+1);
				result[result.length-1]=suits[index];
			}
			count++;
		}
		for(int i=0;i<result.length;i++){
			System.out.printf("%s of %s\n",ranks[(int) (Math.random()*13)],result[i]);
		}
		System.out.println("Number of picks:"+count);
	}
	private static boolean isContains(String[] result, String suit) {
		for(int i=0;i<result.length;i++){
			if(result[i].equals(suit)){
				return true;
			}
		}
		return false;
	}
}

import java.util.Arrays;
import java.util.Scanner;
public class Demo6_10 {
	public static void main(String[] args) {
		//输入两个数组
		Scanner scanner=new Scanner(System.in);
		System.out.print("Enter list1:");
		int len1=scanner.nextInt();
		int[] list1=new int[len1];
		for(int i=0;i<list1.length;i++){
			list1[i]=scanner.nextInt();
		}
		System.out.print("Enter list2:");
		int len2=scanner.nextInt();
		int[] list2=new int[len2];
		for(int i=0;i<list2.length;i++){
			list2[i]=scanner.nextInt();
		}
		System.out.println(equals(list1,list2));
	}
	//判断数组是否完全相同
	public static boolean equals(int[] list1,int[] list2){
		//判断长度
		Arrays.sort(list1);//6_11
		Arrays.sort(list2);//6_11
		if(list1.length!=list2.length){
			return false;
		}
		for(int i=0;i<list1.length;i++){
			if(list1[i]!=list2[i]){
				return false;
			}
		}
		return true;
	}
}

import java.util.Arrays;
import java.util.Scanner;
public class Demo6_12 {
	public static void main(String[] args) {
		Scanner scanner=new Scanner(System.in);
		System.out.print("Enter ten numbers:");
		int[] nums=new int[0];
		for(int i=0;i<10;i++){
			int num=scanner.nextInt();
			if(!isContains(nums,num)){
				nums=Arrays.copyOf(nums,nums.length+1); 
				nums[nums.length-1]=num;
			}
		}
		for(int i=0;i<nums.length-1;i++){
			for(int j=i+1;j<nums.length;j++){
				System.out.printf("[%s,%s]",nums[i],nums[j]);
			}
			System.out.println();
		}
	}
	private static boolean isContains(int[] nums, int num) {
		for(int i=0;i<nums.length;i++){
			if(nums[i]==num){
				return true;
			}
	    }
		return false;
   }
}

6.13

import java.util.Scanner;
public class Demo6_13 {
	public static void main(String[] args) {
		//输入数组长度
		Scanner scanner=new Scanner(System.in);
		System.out.print("Enter the number of values:");
		int len=scanner.nextInt();
		if(len<0){
			System.out.println("Illegal input!");
		}
		//输入数组中的每一个元素
		System.out.print("Enter the values:");
		int[] nums=new int[len];
		for(int i=0;i<nums.length;i++){
			nums[i]=scanner.nextInt();
		}
		boolean b=isConsecutiveFour(nums);
		System.out.println(b);
	}
	private static boolean isConsecutiveFour(int[] nums) {
		for(int i=0;i<nums.length;){
			int count=1;
			for(int j=i+1;j<nums.length;j++){
				if(nums[i]==nums[j]){
					count++;
				}else{
					break;
				}
			}
			i=i+count;
			if(count>=4){
				return true;
			}
		}
		return false;
	}
}

import java.util.Arrays;
import java.util.Scanner;
public class Demo6_14 {
	public static void main(String[] args) {
		Scanner scanner=new Scanner(System.in);
		System.out.print("Enter list1:");
		int len1=scanner.nextInt();
		int[] list1=new int[len1];
		for(int i=0;i<list1.length;i++){
			list1[i]=scanner.nextInt();
		}
		System.out.print("Enter list2:");
		int len2=scanner.nextInt();
		int[] list2=new int[len2];
		for(int i=0;i<list2.length;i++){
			list2[i]=scanner.nextInt();
		}
		int[] list3=merge(list1, list2);
		System.out.println(Arrays.toString(list3));
	}
	public static int[] merge(int[] list1,int[] list2){
		for(int i=0;i<list2.length;i++){
			list1=Arrays.copyOf(list1, list1.length+1);
			list1[list1.length-1]=list2[i];
		}
		Arrays.sort(list1);
		return list1;
	}
}

import java.util.Scanner;
public class Demo6_15 {
	/*
	 * 1.随机抽取一个单词
	 * 2.创建与该单词长度一致的布尔数组
	 * 3.根据布尔数组的状态 打印单词 false打印* true打印相应字母
	 * 4.用户输入一个字母
	 * 5.判断该字母是否在在单词中出现
	 * 	5.1如果出现 
	 * 		5.1.1 密文 出现的单词对应的状态置位true
	 * 		5.1.2 明文 存在且为true 提示已经存在
	 * 	      执行3
	 *  5.2如果不存在 错误计数+1
	 *     执行3
	 * 6.直到状态全为true结束此次猜词
	 * 7.提示是否下一次游戏 执行1
	 * */
	public static void main(String[] args) {
		String[] words={"gaolin","liumaojing","wangzhengchuan","aojun","liuqiming","liuaiji","douyansong"};
		Scanner scanner=new Scanner(System.in);
		while(true){
			String word=words[(int) (Math.random()*words.length)];
			boolean[] stauts=new boolean[word.length()];
			int missCount=0;
			while(!isStautsAllTrue(stauts)){//返回状态数组是否全为true
				String info=getWordByStauts(word,stauts);
				System.out.print("(Guess) Enter a letter in word "+info+">");
				String letter=scanner.next();
				if(isLetterInWord(letter,word)){
					if(isLetterStautsTrue(letter,word,stauts)){
						System.out.printf("\t %s is already in the word\n",letter);
					}else{
						changeLetterStauts(letter,word,stauts);
					}
				}else{
					missCount++;
					System.out.printf("\t %s is not in word\n",letter);
				}
			}
			System.out.printf("The word is %s .You missed %d time\n",word,missCount);
			System.out.print("Do you want to guess another word?(y/n)");
			String choice=scanner.next();
			if(choice.equalsIgnoreCase("n")){
				break;
			}
		}
		System.out.println("Game over!");
	}
	private static void changeLetterStauts(String letter, String word,
			boolean[] stauts) {
		for(int i=0;i<word.length();i++){
			if(letter.equals(word.charAt(i)+"")){
				stauts[i]=true;
			}
		}
	}
	private static boolean isLetterStautsTrue(String letter, String word,
			boolean[] stauts) {
		for(int i=0;i<word.length();i++){
			if(letter.equals(word.charAt(i)+"")){
				return stauts[i];
			}
		}
		return false;
	}
	private static boolean isLetterInWord(String letter, String word) {
		for(int i=0;i<word.length();i++){
			if(letter.equals(word.charAt(i)+"")){
				return true;
			}
		}
		return false;
	}
	private static String getWordByStauts(String word, boolean[] stauts) {
		String info="";
		for(int i=0;i<stauts.length;i++){
			if(stauts[i]){
				info+=word.charAt(i);
			}else{
				info+="*";
			}
		}
		return info;
	}
	private static boolean isStautsAllTrue(boolean[] stauts) {
		for(int i=0;i<stauts.length;i++){
			if(stauts[i]==false){
				return false;
			}
		}
		return true;
	}
}