List<String> list=new ArrayList<>();
		list.add("a");
		//第一种
		Iterator<String> iterator=list.iterator();
		while(iterator.hasNext()) {
			System.out.println(iterator.next());
			iterator.remove();//移除
		}
		//第二种
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
			list.remove(i)//移除
		}

TreeSet<UpdateStu>tree =new TreeSet<>();
UpdateStu stu1=new UpdateStu("李同学", 01011);
UpdateStu stu2=new UpdateStu("陈同学",01021);
...;
tree.add(stu1);
tree.add(stu2);
tree.add(stu3);
tree.add(stu4);
Iterator<UpdateStu> it=tree.iterator();
it=tree.headSet(stu2).iterator();
System.out.println("截取前面部分的集合：");
while(it.hasNext()){
	System.out.println(it.next());			
}
it=tree.subSet(stu2, stu3).iterator();
System.out.println("截取中间部分的集合");
while(it.hasNext()){
	System.out.println(it.next());
}

File file=new File("MyFile.txt");

FileOutputStream outputStream=new FileOutputStream(file);//创建输出流
byte buy[]="Java程序设计".getBytes();//准备字节数组
outputStream.write(buy);//写入
outputStream.close();

FileInputStream inputStream=new FileInputStream(file);//准备输入流
byte byt[]=new byte[1024];//准备字节数组接收
int len=inputStream.read(byt);//read读取
inputStream.close();

System.out.println("文件长度："+file.length()+"字节");
System.out.println("文件路径："+file.getAbsolutePath());
SimpleDateFormat simpleDateFormat=new SimpleDateFormat("YYYY-MM-dd HH:mm:ss");
System.out.println("修改时间"+simpleDateFormat.format(file.lastModified()));

FileWriter fw=new FileWriter(file);
BufferedWriter bw=new BufferedWriter(fw);
String str="你好";
bw.write(str);//写入字符串
bw.newLine();//写入换行符

FileReader fr=new FileReader(file);
BufferedReader br=new BufferedReader(fr);
String tmp=null;//缓存临时字符串
while ((tmp=br.readLine())!=null) {
	System.out.println(tmp);//输出每一行
}

class MyJDialog extends JDialog{
	public MyJDialog(MyFrame frame) {//参数是MyFrame
		super(frame,"这是一个对话框",flase);//窗体、标题、是否阻塞
		Container container=getContentPane();//获取主窗体
		container.add(new JLabel("这是一个对话框"));//在容器中添加标签
		setBounds(120,120,100,100);//设置对话框在桌面显示的坐标和大小
	}
}
public class MyFrame extends JFrame{
	public MyFrame() {
		Container container=getContentPane();//获取窗体主容器
		
		bl.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				new MyJDialog(MyFrame.this).setVisible(true);
			}
		});
		container.add(bl);
		setVisible(true);
	}
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		new MyFrame();
	}

}

class ms{
	private Thread consume;
	private Thread product;
	private Random random=new Random();
	private int count=0;
	private Stack<Integer> st=new Stack<Integer>();
	public ms() {
		
		product=new Thread(new Runnable() {
			public void run() {
				while(true) {
						try
						{
							if(count<10)
							{
								int s=random.nextInt(1000);
								st.push(s);
								count++;
								System.out.println("生产数据"+s);
								Thread.sleep(1);
							}
							else
								Thread.sleep(100);
						} 
						catch (Exception e) {
							// TODO: handle exception
						}	
			}
		}});
		product.start();
		
		consume=new Thread(new Runnable() {
			public void run() {
				while(true) {
						try
						{
							if(count>0)
							{								
								int s=st.pop();
								count--;
								System.out.println("消费数据："+s);
								Thread.sleep(1);
							}
							else 
								Thread.sleep(100);
						} 
						catch (Exception e) {
							// TODO: handle exception
						}	
			}
		}});
		consume.start();
	}
}

public class Lab14_4{

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		new ms();
	}

}

class MySever{
    public ServerSocket sever;//创建热线
    public Socket socket;//客服
    private PrintWriter writer;//输出流
    void start(){
        //绑定端口
        server=new ServerSocket(8998);
        while(true){
            socket=server.accept();//等待接收，阻塞
            //套接字客服传信息，用缓存输入流，里边是InputStreamReader，再里边是socket.getInputStream
            BufferedReader reader=new BufferedReader(new InputStreamReader(socket.getInputStream));
            writer=new PrintWriter(socket.getOutputStream,true);
            while(true){//又一个
                //字符串接数据 readerLine()
                String message=reader.readerLine();
                wrter.println("收到，谢谢你！");
            }
            reader.close();//先关流
            socket.close();
        }
    }
}

class MyClient{
    Socket socket;//套接字
    private PrintWriter writer;//写数据，用PrintWriter而不是Buffer
    private BufferedReader reader;//输入流，读取
    public MyClient(){
        //一些修饰，如swing之类的
        
        //传数据
        String message="hello";//准备数据
        writer.println(message);//传输即可
    }
    //连接另外写一个函数
    public void connect(){
        socket=new Socket("127.0.0.1",8998);//绑定ip和端口
        writer=new PrintWriter(socket.getOutputStream(),true);//创建流，一层就够了
 		//接收信息
        reader=new BufferedReader(new InputStreamReader(socket.getInpuString));
        //准备线程
        readThread=new Thread(new Runnable() {
			
			@Override
			public void run() {
                String message=reader.reaLine();
                syso(message);
            }
        }
    }
}

//指定地址
//实例化，绑定端口
//加入组
//构造里配置，run里边接收/发送
//准备DataPackage，字符转字节数组，发送socket.send()
class Notification extends Thread{
    int port;//端口
    InetAddress iAddress=null;//ip
    MulticastSocket socket=null;//MulticastSocket socket
    String weather=new String();//发送的信息
    public Receive() {
    	//配置
    	//指定地址
    	try {
    		port=9898;
			iAddress=InetAddress.getByName("224.255.10.0");//getByName返回的InetAddress
			MulticastSocket socket=new MulticastSocket(port);
			socket.setTimeToLive(1);
			socket.joinGroup(iAddress);
		} catch (UnknownHostException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
    }
    @Override
    public void run() {
    	// 发送信息
    	//准备
    	DatagramPacket packet=null;
    	byte data[]=weather.getBytes();//字符转字节数组
    	packet=new DatagramPacket(data, data.length, iAddress, port);
    	socket.send(packet);
    	sleep(100);
    }
}

class Receive implements Runnable{
    int port;//端口
    InetAddress group=null;//ip
    MulticastSocket socket=null;//MulticastSocket socket
    
    public Receive() {
    	//配置
    	//指定地址
    	try {
    		port=9898;
    		group=InetAddress.getByName("224.255.10.0");//getByName返回的InetAddress
			MulticastSocket socket=new MulticastSocket(port);
			socket.joinGroup(group);
		} catch (UnknownHostException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
    }
    @Override
    public void run() {
    	byte bty[]=new byte[1024];
    	DatagramPacket packet=new DatagramPacket(bty, bty.length, group, port);
    	try {
			socket.receive(packet);
		} catch (IOException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
    	String message=new String(packet.getData(), 0, packet.getLength());
    	System.out.println(message);
    }
}

package Lab2;
class newClass extends Lab1.myClass{//包名.类名
    
}

Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
String str1=sc.next();
System.out.println("欢迎"+n+"号同学"+str1);

for(元素类型x:遍历对象obj){
    引用了x的java语句;
}

public class Repetition{
    public static void main(String args[]){
        int arr[]={5,13,96};
        System.out.println("一维数组中的元素分别为：");
        //x的类型与arr元素的类型相同 。for循环依次取出arr中的值并赋给x
        for(int x:arr){
            System.out.println(x);
        }
    }
}

/*输出结果：
一维数组中的元素分别为：
5
13
96
*/

public void setName(String name){//定义一个setName()的方法
    this.name=name;//将参数值赋予类中的成员变量
}

public class eggCake{
    int eggCount;
    public EggCake(int eggCount){//有参构造
        this.eggCount=eggCount;
    }
    public EggCake(){
        //设置鸡蛋灌饼里蛋的个数为1
        this(1);
    }
}

public class Lab2_1{
    
    public static void main(String[] args){
        new Lab2_1().show();//临时无名对象
        //如果是show.()直接调用会报错，除非把show 声明为静态函数，说这是上面的方法，调用类内成员函数
    }
    void show(){
        System.out.println("Hello!")
    }
}

public class Lab2_1{
    
    public static void main(String[] args){
        Lab2_1 l2=new Lab2_1();
        //l2=null; 销毁对象 之后如果是l2.show();那么会报错NullPointerException 
    }//超过作用域 对象l2销毁
    void show(){
        System.out.println("Hello!")
    }
}

public class Student{
    String name;
    int age;
    
    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }
    
    @Override//加这个帮助检查重写的函数名是否正确
    public String toString(){
        return "我叫"+name+",今年"+age+"岁。";
    }
    public static void main(String[] args){
        Student s1=new Student("张三",16);
        System.out.println(s1);//就是System.out.println(s1.toString());
    }
}

try{
    //想要正确执行，但是不可控的语句段
    //数据输入输出、网络连接、文件读写、数据库连接访问
}catch(Exception e){
    //可以有多个catch语句，捕获不同的异常 
    //必须是小范围异常(异常类)在前，Exception必须放在最后，Exception是所有异常的基类，范围最大
}
finally{
    //不管是否有捕获异常，都想要执行的代码
}

char a[]={'g','o','o','d'};
String s = new String(a);//相当于String s = new String("good")

char a[]={'g','o','o','d'};
String s = new String(a,1,2);//相当于String s = new String("oo")

System.out.println(s[0]);//是错误的
System.out.println(s.charAt[0]);//才对

String str="We are students";
int size=str.indexOf("a");
int size2=str.toLowerCase().indexOf("a");//转为小写再查找，这个toLowerCase()或toUpperCase()是生成新的字符串对象，不会修改原来的字符串

String str="Hello World";
String substr=str.substring(3);

String s1="abc";
String s2="abc";
String s3=new String("abc");
String s4=new String("abc");
System.out.println(s1==s2);//结果是true
System.out.println(s3==s4);//结果是false

@Override
public boolean equals(Object obj) {
    if (obj instanceof Person) {
       Person person = (Person) obj;
       return name.equalsIgnoreCase(person.getName().trim());
     }
       return false;
}

String regex1="[a-zA-Z_$]+[a-zA-Z_$]*";//
String regex2="[1-9][0-9]{4,10}*";//qq号码规则

package lesson5;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegExp {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		String contentString="1998,1239,12,144";
		//1.\\d表示一个任意的数字
		String regString="\\d\\d\\d\\d";//找四个连续的数字,分组的话是(//d)(//d)
		//2.创建模式对象[即正则表达式对象]
		Pattern pattern=Pattern.compile(regString);
		//3.创建匹配器
		//说明：创建匹配器matcher，按照正则表达式的规则去匹配content字符串
		Matcher matcher=pattern.matcher(contentString);
		//4.开始匹配
		/*
		 * match.find()完成的任务 (考虑分组，如(//d//d)(//d//d))
		 * 1. 根据给定的规则，定位满足规则的字符串（如1999,分组即(19)(99))
		 * 2. 找到时，将字符串的开始的索引记录到matcher对象的属性 int[] groups;
		 *    2.1groups[0]=0，把该子字符串的结束的索引+1的值记录到group[1]=35,+1是因为取字符串左闭右开
		 *    2.2 记录第一组()匹配的字符串的区间group[2]=0,group[3]=2
		 *    2.3 记录第二组()匹配的字符串的区间group[4]=2,group[5]=4
		 *    2.4 如果有更多分组以此类推
		 * 3. 同时记录oldLast的值为子字符串的结束的索引+1的值即5，那下一次执行find时，从5开始匹配
		 */
		while(matcher.find()) {
			System.out.println("找到："+matcher.group(0));//group(0)记录找到的字符串开头,同时可以找到结尾
			System.out.println("第一组()的值： "+matcher.group(1));//19
			System.out.println("第二组()的值： "+matcher.group(2));//99
		}
	}

}

int num = Integer.parseInt("456");//返回包含在由str指定的字符串中的数字的等价整数值
Integer iNum=Integer.valueOf("456");//返回保存指定的String值的Integer对象
iNum.equal(num);//比较，返回值是true

Double dNum=Double.valueOf("3.14");
Double.isNaN(dNum.doubleValue());//是否返回非数字(NaN)值
dNum.intValue();//转为int类型

Boolean b1=Boolean.valueOf("true");
Boolean b2=Boolean.valueOf("ok");
b1.booleanValue();//将Boolean对象的值以对应的boolean值返回，值为true
b2.booleanValue();//值为false

Character mychar1=Character.valueOf('A');//返回保存指定char值的Character对象
Character.isUpperCase(mychar1);//判断是否为大写字母
Character.toUpperCase(mychar1);//转为大写
Character.toLowerCase(mychar1);//转小写，不改变原来字符串

Collection<类名> list=new ArrayList<>();//尖括号只能呢是类，比如不能放int要放integer

import java.util.*;
public class Muster{
    public static void main(String args[]){
        Collection<String> list=new ArrayList();
        list.add("《Java从入门到精通》");
        list.add("《java实战》");
        lteratior<String> it=list.lterator();
        while(it.hasNext()){
            String str=(String)it.next();//获取集合中的元素
            System.out.println(str);
        }
    }
}

List<E> list=new ArrayList<>();
List<E> list2=new LinkedList<>();

Set<类名> set=new TreeSet<>();

Map<String,String> map=new HashMap();
map.put("1001","java从入门到精通");

//声明为int/String类型方便switch case用
//接口
interface SeasonInterface{
    int Spring=1,SUMMER=2,AUTUMN=3,WINTER=4;
    //开头隐含的public static final
}
//枚举
enum SeasonEnum{
    SPRING,SUMMER,AUTUMN,WINTER
}
public class SeasonDemo{
    public static void printSeason1(int season){
        switch(season){
            case SeasonInterface.SPRING:
                System.out.println("这是春季");
                break;
            case SeasonInterface.SUMMER:
                System.out.println("这是夏季");
                break;
            case SeasonInterface.AUTUMN:
                System.out.println("这是秋季");
                break;
            case SeasonInterface.WINTER:
                System.out.println("这是冬季");
                break;
        }
    }
}

父类 a=new 子类();//向上转型
子类 b=(子类)a;//向下转型
子类 b=new 父类();//！这是不可行的！

public class Test{
    private Object b;
    public Object getB(){
        return b;
    }
    public void setB(Object b){
        this.b=b;
    }
    public static void main(String[] args){
        Test t=new Test();
        t.setB(Boolean.valueOf(true));//向上转型
        System.out.println(t.getB());
        t.setB(Float.valueOf("12.3"));
        Float f=(Float)t.getB();//向下转型
        System.out.println(f);
    }
}

类型<T>

public class LimitClass<T extends List>{
    public static void main(Stirng[] args){
        //可以实例化已经实现List接口的类
        LimitClass<ArrayList> l1=new LimitClass<ArrayList>();
        //这句是错误的，因为HashMap类没有实现List()接口
        LimitClass<HashMap> l3=new LimitClass<HashMap>();
    }
}

A<?> a;
A<? extends anyClass> a;
A<?> a= new List<>;//这样是不可以的，实例化需要要具体的类型

//函数式接口
interface A{
    void action();
}
//使用匿名类创建对象
A a=new A(){
    public void action(){
         System.out.println("创建了接口的匿名对象");
    }
};
//使用lambda表达式创建
A a=()->{
    System.out.println("创建了接口的匿名对象");
};

()->结果表达式
参数->结果表达式
//多形参
(参数1,参数2,...,参数n)->结果表达式

//函数式接口
interface AdditionInterface{
    int add(int a,int b);
}

public class ParamterDemo{
    public static void main(String[] args){
        //lamba 表达式实现加法接口，返回参数相加的值(自动加return)
        AdditionInterface np=(x,y)->x+y;
        int result=np.add(15,26);//调用接口方法
        System.out.println("相加结果："+result);//输出相加结果
        //而同一个接口可以实现不同的方法,关键在于接口的实现方式
        AdditionInterface np2=(a,b)->a*b;
        result=np2.add(a,b);
        System.out.println("相乘结果："+result);//输出相乘结果
    }
}

interface StaticMethodInterface{
	int method(int a,int b);
}
public class StaticM

//数据转化为流
public class FilerDemo{
    public static void main(String[] args){
        List<Employee> list=Employee.getEmpList();
        Stream<Employee> stream=list.stream();
        stream=stream.filter(people->people.getAge()>30);//过滤出符合条件的数据
        List<Employee> result=stream.collect(Collectors.toList());//将流对象重新封装成一个List集合
        List<Employee> result2=list.stream().filter(p->p.getDept().equals("开发部")).peek(p->p.setSalary(p.getSalary()*10)).collect(Collect.toList());//过滤得到符合的让其工资翻十倍
        for(Employee emp:result){
            System.out.println(emp);//输出员工信息
        }
    }
}

File(String pathname)
File(String parent,String child)
File(File f,String child)

import java.io.File;
public class FileTest{
    public static void main(String[] args){
        File file=new File("word.txt");//相对路径，是在项目目录下创建而不是在所在包类,此时是在内存中创建对象
		//File file2=new File("D:\\1.txt");//绝对路径
        if(file.exists()){//如果存在
            file.delete();
            System.out.println("文件已删除");
        }else{
            try{
                file.createNewFile();//这一步才真正在磁盘中创建文件
                System.out.println("文件已创建");
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

public class FileStreamDemo{
    public static void main(String[] args){
        File file=new File("D:\\word.txt");//创建文件对象
        //写入
        try{
            FileOutputStream out=new FileOutputStream(File);//创建输出对象
            byte buy[]="我有一只小毛驴".getBytes();//写入内容的字节数组，字符串转转字节
            out.write(buy);//将字节写入到文件
            out.close();//关闭流
        }catch(IOException e){
            e.printStackTrace();
        }
        try{
            FileInputStream in=new FileInputStream(file);//创建输入流
            byte byt[]=new byte[1024];//缓存字节流
            int len=in.read(byt[]);//字节转字符串要用
            System.out.println("文件的信息是："+new String(byt,0,len));//字节转为字符串输出
            in.close();
        }catch(IOException e){
            e.printStackTrace();
        }
    }
}

File file=new File("D:\\word.txt");//创建文件对象
//写入
FileWriter fw=new FileWriter(file);
String word="我有一只小毛驴";
fw.write(word);
fw.close();
//读取
FileReader fr=new FileReade(file);
char ch[]=new char[1024];//缓存字符数组
int len=fr.read(ch);
System.out.println("文件的信息是："+new String(ch,0,len));//字节转为字符串输出
fr.close();

BufferedReader br = new BufferedReader(new FileReader(file));//缓存输入流

public class test2 {
	public static void main(String[] args) {
		String content[]= {"好久不见","最近好吗","常联系"};
		File file=new File("word.txt");
		try {
			BufferedWriter bWriter=new BufferedWriter(new FileWriter(file));//文件字符输出流转缓冲输出流
			for (int k = 0; k < content.length; k++) {
				bWriter.write(content[k]);//写入字符串
				bWriter.newLine();//写入一个换行符
			}
			bWriter.close();//关闭缓冲输出流
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		try {
			BufferedReader bReader=new BufferedReader(new FileReader(file));//文件字符输入流转缓冲输入流
			String tmpString=null;//作为缓冲的临时字符串
			int i=1;//行数
			//从文件重读取一行，如果读出内容不为null，则进入循环
			while ((tmpString=bReader.readLine())!=null) {
				System.out.println("第"+i+"行："+tmpString);
				i++;
			}
			bReader.close();
		} catch (Exception e) {
			// TODO: handle exception
		}
	}
}

输出：
第1行：好久不见
第2行：最近好吗
第3行：常联系

import java.io.*;
import java.net.*;

public class GetPageCode{

	public static void main(String[] args) throws IOException {
		// TODO 自动生成的方法存根
		URL page = null;
		try {
			page = new URL("https://www.qq.com");
		} catch (MalformedURLException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}

		HttpURLConnection conn = (HttpURLConnection) page.openConnection();

		InputStreamReader in = new InputStreamReader(conn.getInputStream());

		BufferedReader buff = new BufferedReader(in);
		String tmp=null;
		int i=1;
		//从流中读出一行，如果内容不为null，则进入循环
		while ((tmp=buff.readLine())!=null) {
			System.out.println(tmp);
			i++;
		}
		
	}

}

Class newC=hashSet.getClass();//获取hashSet的描述信息，假设hashSet是一本书，那newC是书的目录，作者等等基本信息但不包括内容
//查构造方法
Constructor[] constructors=mewC.getDeclaredConstructor;
for(Constructor constructor:constructors){
    System.out.println(constructor);//找到构造函数foreach遍历显示
}
declarednewC=newC.getDeclaredConstructors();

Field[] declaredFields=demClass.getDeclaredFields();
		for(Field field:declaredFields) {
			System.out.println(field);
		}

//查成员方法 用户输入参数
Method[] declaredMethods=demClass.getDeclaredMethods();
		for(Method method:declaredMethods) {
			System.out.println(method);
		}
		Scanner scanner=new Scanner(System.in);
		String key=scanner.next();
		for(Method method:declaredMethods) {
			if(key.equals("size")&&key.equals(method.getName())) {
				try {
					System.out.println(method.invoke(hashSet));
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
			if (key.equals("add") && key.equals(method.getName())) {//作判断才知道用户要做那个
				String addString = scanner.next();
				try {
					System.out.println(method.invoke(hashSet, addString));
					for (String hash : hashSet) {
						System.out.print(hash+" ");
					}
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
			
		}
		scanner.close();

public class AbsolutePosition extends JFrame{

	public AbsolutePosition() {
		setTitle("绝对布局");
		setLayout(null);//取消布局管理器
		setBounds(0,0,300,150);
		Container container=getContentPane();
		JButton b1=new JButton("按钮1");
		JButton b2=new JButton("按钮2");
		b1.setBounds(10,30,80,30);//设置按钮位置和大小
		b2.setBounds(60,70,100,20);
		container.add(b1);
		container.add(b2);
		setVisible(true);
		setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
	}
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		new AbsolutePosition();
	}

}

public class BorderLayoutPosition extends JFrame{
	public BorderLayoutPosition() {
		setTitle("边界布局管理器");
		Container container=getContentPane();
		setLayout(new BorderLayout());//使用边界布局管理器
		JButton centerButton=new JButton("中");
		JButton northButton=new JButton("北");
		JButton southButton=new JButton("南");
		JButton westButton=new JButton("西");
		JButton eastButton=new JButton("东");
		container.add(centerButton,BorderLayout.CENTER);
		container.add(eastButton,BorderLayout.EAST);
		container.add(westButton,BorderLayout.WEST);
		container.add(southButton,BorderLayout.SOUTH);
		container.add(northButton,BorderLayout.NORTH);
		setSize(350,200);
		setVisible(true);
		setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
	}
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		new BorderLayoutPosition();
	}

}

public class GridLayoutPosition extends JFrame{
	public GridLayoutPosition() {
		Container container=getContentPane();
		setLayout(new GridLayout(7,3,5,5));//7行3列网格，组件水平间距5像素，垂直间距5像素
		for (int i = 0; i < 20; i++) {
			container.add(new JButton("button"+i));
		}
		setSize(300,300);
		setTitle("网格布局管理器");
		setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
	}
	public static void main(String[] args) {
		// TODO 自动生成的方法存根

	}

}

Jpanel p1=new JPanel(new GridLayout(1,4,10,10));//初始化面板，使用1行4列的网格布局，组件水平间隔10像素，垂直间隔10像素

File file=new File("src/[文件名]");

JButton b1=new JButton("按钮");
bl.addActionListener(new ActionListener() {
			
	@Override
	public void actionPerformed(ActionEvent e) {
	// 要触发的动作
				
	}
});

public class SimpleEvent extends JFrame{
    private JButton jb=new JButton("我是按钮");
    public SimpleEvent(){
        jb.addActionListener(new jbAction());
    }
    class jbAction implements ActionListener{
        public void actionPerformed(ActionEvent arg0){
            jb.setText("我被点击了");
        }
    }
}

public interface KeyListener extends EventListener{
    //发生击键事件时触发
    public void keyTyped(KeyEvent e);
    //按键被按下时被触发
    public void ketPressed(KeyEvent e);
    //案件被释放时被触发
    public void keyReleased(KeyEvent e);
}

textField=new JTextField();
textField.addKeyListener(new KeyAdapter(){//文本框添加键盘事件的监听
    public void keyPressed(KeyEvent e){//按键按下时触发
        //实现的功能
    }
})

public interface MouseListener extends EventListener{
    public void mouseEntered(MouseEvent e);//光标移入组件时触发
    public void mousePressed(MouseEvent e);//鼠标按键按下
    public void mouseReleased(MouseEvent e);//鼠标按键释放时被触发
    public void mouseClicked(MouseEvent e);//发生单击事件被触发
    public void mouseExited(MouseEvent e);//光标移出组件时被触发
}

private void mouseOper(MouseEvent e){
    int i=e.getButton();//获得按键的int值
    if(i==MouseEvent.BUTTON1)
        System.out.println("按下的是鼠标左键");
    else if(i==MouseEvent.BUTTON2)
        System.out.println("按下的是鼠标滚轮");
    else if(i==MouseEvent.BUTTON3)
        System.out.println("按下的是鼠标右键");
}
public MouseEvent_Example(){
    final JLable label=new JLable();
    label.addMouseListener(new MouseListener(){
        public void mouseEntered(MouseEvent e){
            System.out.println("光标移入组件");
        }
        public void mousePressed(MouseEvent e){
            System.out.print("鼠标按键被按下");
            mouseOper(e);
        }
    })
}

public class Threadtest extends Object implements Runnable{
    @Override
	public void run() {
		// TODO 自动生成的方法存根
		String string=Thread.currentThread().getName();
		for (int i = 0; i < 10; i++) {
			System.out.println(string+"第"+i+"次操作");
		}
	}
	public static void main(String[] args)  {
		Threadtest threadtest=new Threadtest();
		Thread t1=new Thread(threadtest,"线程1");//第二个是Thread的名字，一般是Thread(String name)
		Thread t2=new Thread(new Threadtest(),"线程2");//匿名方式
		t1.start();
		t2.start();
	}
}

Thread thread=new Thread(new Runnable(){
    @Override
    public void run(){
        
    }
})  

public class SwingAndThread extends JFrame{
	int count=0;//图像横坐标
	public SwingAndThread() {
		setBounds(300,200,250,100);
		Container container=getContentPane();//主容器
		container.setLayout(null);
		
		Icon icon=new ImageIcon("src/1.gif");
		JLabel jLabel=new JLabel(icon);
		jLabel.setBounds(10,10,200,50);
		Thread thread=new Thread() {//匿名线程对象
			public void run() {
				while (true) {
					jLabel.setBounds(count,10,200,50);//将标签的横坐标用变量表示
					try {
						Thread.sleep(500);//休眠500毫秒
					} catch (InterruptedException e) {
						// TODO: handle exception
						e.printStackTrace();
					}
					count+=4;//横坐标每次增加4
					if(count>=200) {
						count=10;//到达最右边时使其回到最左边
					}
				}
			}
		};
		thread.start();
		container.add(jLabel);
		setVisible(true);
		setDefaultCloseOperation(EXIT_ON_CLOSE);
	}
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		new SwingAndThread();
	}

}

public static void main(Stirng[] args){
    类 A=new 类();
}
public 类{
    线程实例化;
    线程.start;
    try{
        线程.join();//这样就插入到主线程
    }catch(..){
        e.printStackTrace();
    }
}

public class Priority implements Runnable{
	String nameString;
	public Priority(String name) {
		this.nameString=name;
	}
	@Override
	public void run() {
		// TODO 自动生成的方法存根
		String tmpString="";
		for (int i = 0; i < 50000; i++) {
			tmpString+=i;//进行50000次字符拼接
		}
		System.out.println(nameString+"线程完成任务");
	}
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Thread aThread=new Thread(new Priority("A"));
		aThread.setPriority(1);
		Thread bThread=new Thread(new Priority("B"));
		bThread.setPriority(3);
		Thread cThread=new Thread(new Priority("C"));
		cThread.setPriority(7);
		Thread dThread=new Thread(new Priority("D"));
		dThread.setPriority(10);
		aThread.start();
		bThread.start();
		cThread.start();
		dThread.start();
	}

}
//结果
D线程完成任务
B线程完成任务
C线程完成任务
A线程完成任务