package com.tedu.day01;
public class Demo_01 {
/**
* @param args
* 循环的几个小问题
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
/*
* 1.数据类型
* int[] arr;
* char chs[];
* 2. 定义，数字问题
* int arr1[]=new int[Integer.MAX.value];
* 3.length
* 最后一个元素 length-1;
* 4.引用(指针)
*
* */
int i=0;
int sum=0;
//
int arr1[]=new int[Integer.MAX_VALUE]; //int最大取值范围
boolean[] b=new boolean[]{true,false};
float[] f={1.0f,2};
int[] arr3=new int[5];
// arr3=null;
arr3=new int[]{};
// System.out.println(arr1.length);
System.out.println(f);
for(;i<=100/*1*/;sum+=i/*2*/,i++/*3*/){
/*4*/
// System.out.println(sum);
/*
*
* 循环的顺序问题
* 124 324 324
* */
}
System.out.println(sum);
}
/*
* 游戏：猜字符
* 提供两个字符数组，功能比较两个字符数组的猜对字符的个数和位置
* 返回值
* 数组：
* 1.概念
* 2.怎么定义数组
* 3.数组的初始化问题
* 4.数组的赋值
* 5.数组的访问
* 6.数组的遍历
*
* 7.数组的复制
* 8.数组的排序
*
*
* */
/*
* 3.程序=算法+数据结构
* 设计好的数据结构会导致好的算法
* 4.数组：
* 1.是相同数据类型的元素组成的集合
* 2.元素按线性顺序排序
* 3.可以通过元素所在位置的顺序号做标识来访问
* 数组是一种数据类型（引用类型）
*
*
* int a=5;
* 声明整形数组a, 包含4个元素
* 每个元素都是int型
* int[] a=new int[4]; 0,0,0.0 每个元素会给一个默认型0
* 声明浮点型，每个默认的是0.0
* double[] b=new double[10];
* 默认是false
* boolean[] b=new boolean[26];
* 3.数组的定义
* int[] arr=new int[4];
* 4.数组的初始化
* int[] arr=new int[3]; 系统已经赋值0,0,0
* int[] arr={1,4,7};
* int[] arr=new int[]{1,4,7} 大括号写值不需要说明多大空间
* int [] arr;
* arr={1,4,7}; //编译出错
* arr=new int[]{1,4,7};
* 5.数组的访问
* 1）通过数组名.length来获取数组的长度
* int[] arr=new int[3];
* arr.length
* 2)int[] arr=new int[3];//
* 通过数组下标来访问数组中的元素，下标从0开始到
* arr.length-1
* arr[0]/arr
* arr[1]=100;
* arr[2]
* arr[3]数组下标越界异常
* arr[arr.length-1]=100;给最后一个元素赋值
*
* int a; 声明整形变量a
* int[] a; 声明整形数组变量a
*
*
* int[] arr=new int[300];
* for(int i=0;i<arr.length;i++){
* arr[i]=100;
* }
* for(int i=0;i<arr.length;i++){
* System.out.printf(arr[i++]);
* }
* for(int i=arr.length-1;i>=0;i--){
* System.out.printf(arr[i]);
* }
*
* arr[0]=100;
* arr[1]=100;
* .....
* att[30000]=100;
* */
//明天内容
/*数组的复制
* 数组的排序
* 方法
*
* 作业：
* 1.定义8中基本
* */
}
package com.tedu.day01;
/*
* 作业：
* 1,定义8中基本类型的数组类型；
* byte,short,int,long,(默认都是0)float(0.0f),double(0.0d),boolean(false),char(空格)
* 2,同时遍历第一题目中定义的数组；
* 3，课后作业2，3
*
*
* */
public class homework {
public static void main(String arg[]){
/* 作业1：如下代码
* 作业2：如下代码
* 作业3：int[]是一种数据类型，所以元素都是整型的，可以通过下标来访问
* int[] arr=new arr[4];int[] arr=new arr[]{0,0,0,0};
*
* 每个定义三种方法
* */
int[] a=new int[8]; //整形数组
int[] a1=new int[]{0,0,0,0,0,0,0,0};
int[] a2; //声明
a2=new int[8]; //初始化
byte[] b=new byte[8]; //字节数组
byte[] b1=new byte[]{0,0,0,0,0,0,0,0};
byte[] b2;
short[] c=new short[8];
short[] c1=new short[]{0,0,0,0,0,0,0,0};
short[] c2;
c2=new short[8];
long[] d=new long[8];
long[] d1=new long[]{0,0,0,0,0,0,0,0};
long[] d2;
d2=new long[8];
float[] e=new float[8];
float[] e1=new float[]{0.0f,0.0f,0.0f,0.0f,0.0f,0.0f,0.0f,0.0f};
float[] e2;
e2=new float[8];
double[] f=new double[8];
double[] f1=new double[]{0.0d,0.0d,0.0d,0.0d,0.0d,0.0d,0.0d,0.0d};
double[] f2;
f2=new double[8];
boolean[] g=new boolean[8];
boolean[] g1=new boolean[]{false,false,false,false,false,false,false,false};
boolean[] g2;
g2=new boolean[8];
char[] h=new char[8]; //默认值是空格
char[] h1=new char[]{‘0‘,‘0‘,‘0‘,‘0‘,‘0‘,‘0‘,‘0‘,‘0‘};
char[] h2;
h2=new char[8];
Sequence(a,a.length);
System.out.println();
Reverse(a, a.length);
/*
* 两个方法顺序输出，逆序输出
* Sequence顺序
* Reverse
* */
}
/*与其他语言不同，Java不允许程序员选择按值传递还是按引用各个参数，基本类型
* byte，short，int，long，float，double，Boolean，char的变量
* 总是按值传递。就对象而言，不是将对象本身传递给方法，而是将对象的引用
* 或者说对象的首地址传递给方法，引用本身是按值传递的——————也就是说，讲
* 引用的副本传递给方法（副本就是说明对象此时有两个引用了），通过对象的引用，方法可以
* 直接操作改对象（当操作该对象时才能改变该对象，而操作引用时源对象是没有改变的）
*
*
* */
/*
* 第一代方法
* */
public static void Sequence(int[] ch,int j){
for(int i=0;i<j;i++){
System.out.print(ch[i]+",");
}
}
public static void Reverse(int[] ch,int j){
for(int i=j-1;i>=0;i--)
System.out.print(ch[i]+",");
}
/*
* 第二代方法，无论是什么类型的数组，都通过Sequence方法顺序输出
* 逆序通过Reverse输出
* */
}
package com.tedu.day01;
import java.util.Scanner;
public class homework2 {
public static void main(String[] args){
/*
* 整数中大于一的自然数中。只能被他本身和1整除
* */
Scanner scanner=new Scanner(System.in);
System.out.print("请输入质数的范围2--");
int max=scanner.nextInt();
scanner.close();
/*
* 判断是不是质数
* 如果n能被2到n的平方根直接的某个数整除，则说明不是质数，直接进入下一次质数的判断即可
* */
int j=0;
for(int n=2;n<=max;n++){
int m=(int)Math.sqrt(n);
int i=2;
for(;i<=m;i++){
if(n%i==0)
break;
}
if(i>m){
System.out.print(n+" ");
if(++j%10==0)
System.out.println();
}
}
System.out.println("\n共有"+j+"个质数");
}
}
package com.tedu.day01;
public class homework3 {
public static void main(String arg[]){
int l;
int[] a=new int[10];
for(int i=0;i<a.length;i++){
a[i]=(int)(100*Math.random());
}
Sequence(a,a.length);
System.out.println();
l=min(a,a.length);
System.out.println(l);
move(a,a.length,l);
}
public static void Sequence(int[] ch,int j){
for(int i=0;i<j;i++){
System.out.print(ch[i]+",");
}
}
public static int min(int[] ch ,int j){
int b=0;
for(int i=0;i<j;i++){
if(ch[i]<=ch[0])
b=ch[i];
}
return b;
}
/*每个元素向后面一移一位
* */
public static void move(int[] ch ,int j,int min1){
int[] b=new int[j+1];
b[0]=min1;
for(int i=1;i<j+1;i++)
b[i]=ch[i-1];
Sequence(b,b.length);
}
}