Java基础2

文件结构

数组

Class5 / com.test1 / Demo5_1.java:

/*
* 功能：数组的必要性
*/
package com.test1;
public class Demo5_1 {
/**
* @param args
*/
public static void main(String[] args)
{
//定义一个可以存放六个float类型的数组
float[] arr=new float[6];
//给数组的各个元数赋值
arr[0]=3;
arr[1]=5;
arr[2]=1;
arr[3]=3.4f;
arr[4]=2;
arr[5]=50;
//算总体重
float all=0;
for(int i=0;i<6;i++)
{
all+=arr[i];
}
System.out.println("总体重是："+all);
//定义一个size=5的int数组
int[] arr1;
arr1=new int[5];
//如果你访问的数组范围大了
//arr[5]=10;
//如何知道数组的大小
System.out.println("数组arr1的大小："+arr1.length);
//滑板比赛
float arr2[]={3,6,7.1f,1.1f,3};
float all2=0;
for(int i=0;i<arr2.length;i++)
{
all2+=arr2[i];
}
System.out.println("平均时间："+(all2/arr2.length));
}
}

Class5 / com.test5_2 / Demo5_2.java:

/*
* 功能：对象数组的使用
*/
package com.test1;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class Demo5_2 {
/**
* @param args
*/
public static void main(String[] args) throws Exception {
//定义一个可以存放四只狗的对象数组
Dog dogs[]=new Dog[4];
//创建一个能存放4只狗的Dog[]对象数组
/*
//给各个狗赋初值
dogs[0]=new Dog();//将dogs[0]存放创建一只狗的空间的地址
dogs[0].setName("花花");
dogs[0].setWeight(4.5f);
*/
//从控制台输入各个狗的信息
InputStreamReader isr=new InputStreamReader(System.in);//IO流
BufferedReader br=new BufferedReader(isr);//将IO流转成Buffer流
for(int i=0;i<4;i++)
{
dogs[i]=new Dog();
System.out.println("请输入第"+(i+1)+"只狗的狗名：");
String name=br.readLine();//从控制台读取狗名
System.out.println("请输入第"+(i+1)+"只狗的体重:");
String s_weight=br.readLine();//从控制台读取体重
float weight=Float.parseFloat(s_weight);//将String转成float类型
//将名字赋给对象
dogs[i].setName(name);
//将体重赋给对象
dogs[i].setWeight(weight);
}
//计算总体重
float allWeight=0;
for(int i=0;i<4;i++)
{
allWeight+=dogs[i].getWeight();
}
//计算平均体重
float avgWeight=allWeight/dogs.length;
System.out.println("总体重="+allWeight+" 平均="+avgWeight);
//找出体重最大的狗
//假设第一只狗体重最大
float maxWeight=dogs[0].getWeight();
int maxIndex=0;
//依次比较狗的体重
for(int i=1;i<dogs.length;i++)
{
if(maxWeight<dogs[i].getWeight())
{
//修改
maxWeight=dogs[i].getWeight();
maxIndex=i;
}
}
System.out.println("体重最大的狗是第"+(maxIndex+1)+"只狗，其体重是："
+dogs[maxIndex].getWeight());
//输入狗的名字，查找它的体重
BufferedReader nam=new BufferedReader(isr);
System.out.println("请输入想要查找体重的狗的名字：");
String dogName=nam.readLine();
for(int i=1;i<dogs.length;i++)
{
if(dogName.equals(dogs[i].getName()))
{
System.out.println(dogName+"的体重是："+dogs[i].getWeight());
}
}
}
/*
* 数组总结：
* 1.数组可存放同一类型数据
* 2.简单数据类型(int,float)数组，可直接赋值
* 3.对象数组定义后，赋值时需要再次为每个对象分配空间[即：new 对象]
* 4.数组大小必须事先指定
* 5.数组名可以理解为执行数组首地址的引用
* 6.数组的下标是从0开始编号的
*/
}
//定义一个狗类
class Dog
{
private String name;
private float weight;
public float getWeight() {
return weight;
}
public void setWeight(float weight) {
this.weight = weight;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

Class5 / com.test1 / Demo5_5.java:

/*
* 功能：二维数组
*/
package com.test1;
public class Demo5_5 {
/**
* @param args
*/
public static void main(String[] args) {
int[][] a=new int[4][6];
a[1][2]=1;
a[2][1]=2;
a[2][3]=3;
//把图形输出
//行
for(int i=0;i<4;i++)
{
//列
for(int j=0;j<6;j++)
{
System.out.print(a[i][j]+" ");
}
System.out.print("\n");
}
}
}

排序与查找

排序介绍

冒泡排序

选择排序

快速排序

Class5 / com.test1 / Demo5_3.java:

/*
* 功能：演示各种排序法
*/
package com.test1;
import java.util.Calendar;
public class Demo5_3 {
/**
* @param args
*/
public static void main(String[] args)
{
int len=10;
int[] arr=new int[len];
for(int i=0;i<len;i++)
{
//让程序随机产生一个1-10000的数
//int t=(int)(Math.random()*10000);
int t=(int)(Math.random()*100);
//Math.random()会随机产生一个0~1的数
arr[i]=t;
}
//int arr[]={1,6,0,-1,9,2,14,24,5};
//创建一个Bubble实例
Bubble bubble=new Bubble();
//在排序前打印系统时间
Calendar cal=Calendar.getInstance();//获得实例
System.out.print("冒泡排序前："+cal.getTime());
bubble.sort(arr);//排序，通过引用修改arr数组的顺序
cal=Calendar.getInstance();//重新获得实例
System.out.print("\n冒泡排序后："+cal.getTime());
//输出冒泡排序后的结果，打印有序数列
System.out.print("\n冒泡排序的结果：");
for(int i=0;i<arr.length;i++)
{
System.out.print(arr[i]+" ");
}
int a=12;
bubble.test(a);//简单数据类型传到函数中，它的改变不会导致外面的修改
System.out.println("\n\na="+a);
//-----------------------------------------------------
//创建一个Select实例
Select select=new Select();
//在排序前打印系统时间
cal=Calendar.getInstance();//获得实例
System.out.print("\n选择排序前："+cal.getTime());
//排序
select.sort(arr);
cal=Calendar.getInstance();//重新获得实例
System.out.print("\n选择排序后："+cal.getTime());
//输出选择排序后的结果，打印有序数列
System.out.print("\n选择排序的结果：");
for(int i=0;i<arr.length;i++)
{
System.out.print(arr[i]+" ");
}
//-------------------------------------------------
//创建一个InsertSort实例
InsertSort is=new InsertSort();
//在排序前打印系统时间
cal=Calendar.getInstance();//获得实例
System.out.print("\n\n插入排序前："+cal.getTime());
//排序
is.sort(arr);
cal=Calendar.getInstance();//重新获得实例
System.out.print("\n插入排序后："+cal.getTime());
//输出选择排序后的结果，打印有序数列
System.out.print("\n插入排序的结果：");
for(int i=0;i<arr.length;i++)
{
System.out.print(arr[i]+" ");
}
//-------------------------------------------------
//创建一个QuickSort实例
QuickSort qs=new QuickSort();
//在排序前打印系统时间
cal=Calendar.getInstance();//获得实例
System.out.print("\n\n快速排序前："+cal.getTime());
//排序
qs.sort(0,arr.length-1,arr);
cal=Calendar.getInstance();//重新获得实例
System.out.print("\n快速排序后："+cal.getTime());
//输出选择排序后的结果，打印有序数列
System.out.print("\n快速排序的结果：");
for(int i=0;i<arr.length;i++)
{
System.out.print(arr[i]+" ");
}
}
}
class Bubble
{
//测试
public void test(int a)
{
a++;
}
//冒泡排序
public void sort(int arr[])
{
int temp=0;
//外层循环,决定一共走几趟
for(int i=0;i<arr.length-1;i++)
{
//内层循环，开始逐个比较，如果发现前一个数比后一个数大，则交换
for(int j=0;j<arr.length-1-i;j++)
{
if(arr[j]>arr[j+1])
{
//换位
temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
}
class Select
{
//选择排序
public void sort(int arr[])
{
int temp=0;//临时变量
for(int j=0;j<arr.length-1;j++)
//j<arr.length说明当只剩最后一个数没比较时，不必再比较了
{
//假设第j个数是最小的数
int min=arr[j];
//记录最小数的下标
int minIndex=j;
for(int k=j+1;k<arr.length;k++)
//k<arr.length说明只剩两个数未比较时，最后一个数要参与比较
{
if(min>arr[k])
{
//修改最小
min=arr[k];
minIndex=k;
}
}
//当退出内层for循环时，就找到这次的最小值
temp=arr[j];
arr[j]=arr[minIndex];
arr[minIndex]=temp;
}
}
}
//插入排序
class InsertSort
{
//插入排序方法
public void sort(int arr[])
{
for(int i=1;i<arr.length;i++)
{
int insertVal=arr[i];
//insertVal准备和前一个数比较
int index=i-1;
while(index>=0&&insertVal<arr[index])
{
//将把arr[index]向后移动一位
arr[index+1]=arr[index];
//让index向前移动
index--;
}
//将insertVal插入到行当位置
arr[index+1]=insertVal;
}
}
}
//快速排序
class QuickSort
{
public void sort(int left,int right,int[] array)
{
int l=left;//左边
int r=right;//右边
int pivot=array[(left+right)/2];//中间的作为隔板数
int temp=0;
while(l<r)
{
while(array[l]<pivot) l++;
while(array[r]>pivot) r--;
if(l>=r) break;
temp=array[l];
array[l]=array[r];
array[r]=temp;
if(array[l]==pivot) --r;
if(array[r]==pivot) ++l;
}
if(l==r)
{
l++;
r--;
}
if(left<r) sort(left,r,array);
if(right>l) sort(l,right,array);
}
}

Class5 / com.test1 / Demo5_4.java:

/*
* 功能：二分查找
*/
package com.test1;
public class Demo5_4 {
/**
* @param args
*/
public static void main(String[] args) {
int arr[]={2,5,7,12,25};
BinaryFind bf=new BinaryFind();
bf.find(0, arr.length-1, 4, arr);
}
}
//二分查找
class BinaryFind
{
public void find(int leftIndex,int rightIndex,int val,int[] arr)
{
//首先找到中间的数
int midIndex=(rightIndex+leftIndex)/2;
int midVal=arr[midIndex];
if(rightIndex>=leftIndex)
{
//如果要找的数比midVal大
if(midVal>val)
{
//在arr的左边数中找
find(leftIndex,midIndex-1,val,arr);//递归
}
else if(midVal<val)
{
//在arr的右边的数找
find(midIndex+1,rightIndex,val,arr);//递归
}
else if(midVal==val)
{
System.out.println("找到下标"+midIndex);
}
}
else
{
System.out.println("没有找到！");
}
}
}

集合类及移位运算

Class7 / com.test1 / Demo7_1.java:

/*
* 功能：演示java集合的用法
*/
package com.test1;
import java.util.*;
public class Demo7_1 {
/**
* @param args
*/
public static void main(String[] args) {
//定数组
//Clerk []clerks=new Clerk[???];
//定义ArrayList对象
ArrayList al=new ArrayList();
//显示大小
System.out.println("al大小："+al.size());
//向al中加入数据(类型是object)
//创建一个职员
Clerk clerk1=new Clerk("宋江",50,1000);
Clerk clerk2=new Clerk("吴用",45,1200);
Clerk clerk3=new Clerk("林冲",35,1300);
//将clerk1加入到al中
al.add(clerk1);
al.add(clerk2);
al.add(clerk3);
//显示大小
System.out.println("al大小："+al.size());
//如何访问al中对象（数据）
//访问第一个对象
Clerk temp=(Clerk)al.get(0);//因为get返回的是一个object
System.out.println("第一个名字是："+temp.getName());
//遍历al所有的对象
System.out.println("删除前");
for(int i=0;i<al.size();i++)
{
Clerk temp1=(Clerk)al.get(i);
System.out.println("名字是："+temp1.getName());
}
//从al中删除一个对象
al.remove(1);//删除吴用
System.out.println("=====删除吴用======");
//删除后
System.out.println("删除后");
for(int i=0;i<al.size();i++)
{
Clerk temp1=(Clerk)al.get(i);
System.out.println("名字是："+temp1.getName());
}
}
}
//定义一个员工类
class Clerk
{
private String name;
private int age;
private float sal;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public float getSal() {
return sal;
}
public void setSal(float sal) {
this.sal = sal;
}
public Clerk(String name,int age,float sal)
{
this.name=name;
this.age=age;
this.sal=sal;
}
}

Class7 / com.test1 / Demo7_2.java:

/*
* 功能：做一个公司职员薪水管理系统，要求完成如下功能：
* 1.当有新员工时，将该员工加入到管理系统
* 2.可以根据员工号，显示该员工的信息
* 3.可以显示所员工信息
* 4.可以修改员工薪水
* 5.当员工离职时，将该员工从管理系统中删除
* 6.可以按照薪水从低到高顺序排序
* 7.可以统计员工的平均工资和最低、最高工资
*/
package com.test1;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
public class Demo7_2 {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
//演示
String a=new String("abc");
String b=new String("abc");
if(a==b)
{
System.out.println("== ok");
}
else if(a.equals(b))
{
System.out.println("equals ok");
}
else ;
//创建EmpManage对象
EmpManage em=new EmpManage();
//Emp emptemp=new Emp(null,null,0);
//定义一个BufferedReader流
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
//作出一个简单菜单
while(true)
{
System.out.println("请选择你要进行的操作：");
System.out.println("1:表示添加一个雇员");
System.out.println("2:查找一个雇员");
System.out.println("3:显示所有雇员信息");
System.out.println("4:修改一个雇员工资");
System.out.println("5:删除一个雇员");
System.out.println("6：退出系统");
String operType=br.readLine();
if(operType.equals("1"))
{
System.out.println("请输入编号：");
String empNo=br.readLine();
System.out.println("请输入名字：");
String name=br.readLine();
System.out.println("请输入工资：");
float sal=Float.parseFloat(br.readLine());
Emp emp=new Emp(empNo,name,sal);
Emp emptemp=em.addEmp(emp);
//这里的"="相当于将返回的emp内存块直接复制一份给emptemp,即创建的同时
//也就初始化了，所心不必再考的emptemp内部的属性是private，还是public,"="相当于直接复制
System.out.println("=====添加"+emptemp.getName()+"成功！======\n");
}
else if(operType.equals("2"))
{
System.out.println("请输入编号：");
String empNo=br.readLine();
//查找
Emp emptemp=em.showInfo(empNo);
System.out.println("=====查找"+empNo+"("+emptemp.getName()+")"+"成功！======\n");
}
else if(operType.equals("3"))
{
//显示所有员工信息
em.showAllInfo();
System.out.println("=====已列出！======\n");
}
else if(operType.equals("4"))
{
System.out.println("请输入编号：");
String empNo=br.readLine();
System.out.println("请输入工资：");
float sal=Float.parseFloat(br.readLine());
//修改
Emp emptemp=em.updateSal(empNo, sal);
System.out.println("=====修改"+empNo+"("+emptemp.getName()+")"+"工资成功！======\n");
}
else if(operType.equals("5"))
{
System.out.println("请输入编号：");
String empNo=br.readLine();
//删除
Emp emptemp=em.delEmp(empNo);
System.out.println("=====删除"+empNo+"("+emptemp.getName()+")"+"成功！======\n");
}
else if(operType.equals("6"))
{
//退出系统
System.exit(0);//0表示正常退出JVM,非0表示异常退出JVM
}
}
}
}
//雇员类
class Emp
{
//学号
private String empNo;
private String name;
private float sal;
public String getEmpNo() {
return empNo;
}
public void setEmpNo(String empNo) {
this.empNo = empNo;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public float getSal() {
return sal;
}
public void setSal(float sal) {
this.sal = sal;
}
//构造函数
public Emp(String empNo,String name,float sal)
{
this.empNo=empNo;
this.name=name;
this.sal=sal;
}
}
//雇员管理类
class EmpManage
{
private ArrayList al=null;
public EmpManage()
{
al=new ArrayList();
}
//加入员工
public Emp addEmp(Emp emp)
{
if(al.add(emp))//如果添加成功
return emp;
else
return null;
}
//显示指定员工的相关信息
public Emp showInfo(String empNo)
{
//遍历整个ArrayList
for(int i=0;i<al.size();i++)
{
//取出Emp对象
Emp emp=(Emp)al.get(i);
//比较编号
if(emp.getEmpNo().equals(empNo));
{
System.out.println("找到该员工，他的信息是：");
System.out.println("编号="+emp.getEmpNo());
System.out.println("名字="+emp.getName());
System.out.println("工资="+emp.getSal());
return emp;
}
}
return null;
}
//显示所有员工的信息
public void showAllInfo()
{
//遍历整个ArrayList
for(int i=0;i<al.size();i++)
{
Emp emp=(Emp)al.get(i);
System.out.print("编号："+emp.getEmpNo()+" "
+"名字："+emp.getName()+" "
+"工资："+emp.getSal()+" "+"\n");
}
}
//修改工资
public Emp updateSal(String empNo,float newSal)
{
for(int i=0;i<al.size();i++)
{
Emp emp=(Emp)al.get(i);
if(emp.getEmpNo().equals(empNo))
{
//修改薪水
emp.setSal(newSal);
return emp;
}
}
return null;
}
//删除员工
public Emp delEmp(String empNo)
{
for(int i=0;i<al.size();i++)
{
Emp emp=(Emp)al.get(i);
if(emp.getEmpNo().equals(empNo))
{
al.remove(i);//按编号删除员工
al.remove(emp);//按对象删除员工
return emp;
}
}
return null;
}
}

Class7 / com.test1 / Demo7_3.java:

/*
* 功能：各种集合的使用
*/
package com.test1;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Stack;
import java.util.Vector;
public class Demo7_3 {
/**
* @param args
*/
public static void main(String[] args) {
//LinkedList的用法
LinkedList ll=new LinkedList();
Emp emp1=new Emp("sa01","宋江",1.2f);
Emp emp2=new Emp("sa02","卢俊义",1.8f);
Emp emp3=new Emp("sa03","吴用",1.5f);
//表示把emp1加在链表的最前面
ll.addFirst(emp1);//向链表的当前结点的前面添加一个emp1结点
ll.addFirst(emp2);//前加
ll.addLast(emp3);//后加
for(int i=0;i<ll.size();i++)
{
System.out.println(((Emp)ll.get(i)).getName());
}
//------------------------------------------------------
//Vector的用法
//Vector与ArrayList的区别
//1.Vector有同步机制，ArrayList没有同步机制
//2.ArrayList缺省情况下自动增长原来的一倍，Vector是原来的50%增长
Vector vv=new Vector();
Emp emp4=new Emp("1","林冲",1.6f);
vv.add(emp4);
for(int i=0;i<vv.size();i++)
{
Emp emp=(Emp)vv.get(i);
System.out.println(emp.getName());
}
//------------------------------------------------------
//栈的用法
Stack stack=new Stack();
Emp emp5=new Emp("8","李逵",1.9f);
Emp emp6=new Emp("9","武松",1.7f);
Emp emp7=new Emp("5","公孙胜",1.7f);
stack.add(emp5);
stack.add(emp6);
stack.add(emp7);
for(int i=0;i<stack.size();i++)
{
Emp emp=(Emp)stack.get(i);
System.out.println(emp.getName());
}
//------------------------------------------------------
//HashMap的用法
//创建一个HashMap对象
HashMap hm=new HashMap();
Emp emp8=new Emp("s001","秦平",2.2f);
Emp emp9=new Emp("s002","花荣",2.3f);
Emp emp10=new Emp("s002","燕青",2.4f);
//将emp放入到
hm.put("s001", emp8);
hm.put("s002", emp9);
hm.put("s002", emp10);//出现键值相同时，会将emp10替换前面的
System.out.println(emp8.getName());
System.out.println(emp9.getName());
//如果要查找编号是s002
if(hm.containsKey("s002"))
{
System.out.println("-----------\n有该员工");
//如何取出,键<-->值
Emp emp=(Emp)hm.get("s002");
System.out.println("名字："+emp.getName());
}
else
{
System.out.println("-----------\n没有该员工");
}
//遍历HashMap中所有的key和value
Iterator it=hm.keySet().iterator();//迭代器
//hasNext返回一个boolean
System.out.println("-------开始遍历HashMap！------");
while(it.hasNext())//hasNext判断是否还有下一个
{
//取出Key
String key=it.next().toString();
//通过Key取出value
Emp emp=(Emp)hm.get(key);
System.out.println("名字："+emp.getName());
}
//HashMap在多线程并发操作时，因为没有同步机制作，
//可能会发生读脏数据，所以引入了安全的Hashtable
//------------------------------------------------------
//Hashtable的用法
Hashtable ht=new Hashtable();
/*
ht.put(null, null);
System.out.println("Hashtable null值测试"+ht.get(null));
//Hashtable不可以存放空值
*/
HashMap hm2=new HashMap();
hm2.put(null, null);//HashMap可以存放空值
System.out.println("HashMap null值测试:"+hm2.get(null));
//Hashtable不可以存放空值
/*
* 集合总结：
* 1.如果要求线程安全，使用Vector,Hashtable
* 2.如果要求线程安全，使用ArrayList,LinkedList,HashMap
* 3.如果要求键值对，则使用HashMap,Hashtable
* 4.如果数据量很大，又要线程安全考虑Vector
*/
}
}

Class7 / com.test1 / Test1.java:

/*
* 功能：位运算和移位运算
*/
package com.test1;
public class Test1 {
/**
* @param args
*/
public static void main(String[] args) {
System.out.println("~2="+(~2));//取反
System.out.println("2&3="+(2&3));//与
System.out.println("2|3="+(2|3));//或
System.out.println("~-5="+(~-5));//取反
System.out.println("-3^3="+(-3^3));//异或
//算术右移：低位溢出，符号位不变，并用符号位补溢出的高位
//算术左移：符号位不变，低位补0
//逻辑右移:低位溢出，高位补零
System.out.println("1>>2="+(1>>2));
System.out.println("-1>>2="+(-1>>2));
System.out.println("1<<2="+(1<<2));
System.out.println("-1<<2="+(-1<<2));
System.out.println("3>>>2="+(3>>>2));//逻辑右移
}
}