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);
}

}

培訓第一天的作業