JAVA-day08 上午-集合零散知识、集合实现贪吃蛇

/*
工具类：
Arrays
Collections

*/
import java.util.*;
class Demo1
{
public static void main(String[] args)
{
int[] arr ={34,56,12,6};

//数组中的内容转成字符串
System.out.println(Arrays.toString(arr));

//数组转成集合

String[] arr2 = {"woeirui","eioruti","lfjgkldfg"};

List<String> list = Arrays.asList(arr2);
sop(list.size());
sop(list);
//因为数组的长度是固定的，所以不能对集合进行添加，删除，修改
//list.add("hello");//UnsupportedOperationException
//sop(list);

//数组转集合有什么用？可以利用集合的方法，因为集合的方法多
list.contains("hello");

Iterator<String> ite = list.iterator();
while(ite.hasNext())
{
sop(ite.next());
}

int[] b = {3,4,5,6};
List  list2 = Arrays.asList(b);
sop(list2.size());///因为集合中存储的是引用类型的对象，所以把整个int类型的数组看成一个对象存到集合中，所以长度是1

}

public static void sop(Object obj)
{
System.out.println(obj);
}
}

import java.util.*;
class Demo2
{
public static void main(String[] args)
{
List<String> list = new ArrayList<String>();

list.add("oewuro");
list.add("dfhfgh");
list.add("yuiyuiyuiyui");
list.add("qweqweqewqeqweqwe");

//数组长度最好是和集合中的对象个数相同
String[] arr = list.toArray(new String[list.size()]);

sop(arr.length);

//为什么集合转数组？数组的长度是固定的，可以限制增删操作

}

public static void sop(Object obj)
{
System.out.println(obj);
}
}

//Collections
import java.util.*;
class CompareByLength implements Comparator<String>
{
public int compare(String str1,String str2)
{
return str1.length()-str2.length();
}
}
class  Demo3
{
public static void main(String[] args)
{
//对象可以重复，还想排序
List<String> list = new ArrayList<String>();

list.add("oewuro");
list.add("dfhfgh");
list.add("yuiyuiyuiyui");
list.add("qweqweqewqeqweqwe");

//Collections.sort(list);
//返回一个和默认排序规则相反的比较器Collections.reverseOrder()
Collections.sort(list,Collections.reverseOrder());

//使用指定的比较器排序
//Collections.sort(list,new CompareByLength());
//Collections.sort(list,Collections.reverseOrder(new CompareByLength()));
sop(list);

//将集合中的对象倒序

//Collections.reverse(list);
//sop(list);

//获取集合中的最值
//String str = Collections.max(list);
//String str = getMax(list);
//sop(str);
}

//实现获取集合中的最大值
public static   <E extends Object & Comparable<? super E>>  E getMax(Collection<? extends E> col)
{
Iterator<? extends E>  ite = col.iterator();
//得到集合中的第一个对象
E obj = ite.next();

while(ite.hasNext())
{
E object = ite.next();
int num = obj.compareTo(object);
if(num<0)
obj = object;

}
return obj;

}

public static void sop(Object obj)
{
System.out.println(obj);
}
}

/*
增强的for循环：不能操作下标，所以在使用数组时通常使用传统的for循环

for(数据类型  变量名：被遍历的Collection集合或数组)
{

}
*/
import java.util.*;
class  Demo4
{
public static void main(String[] args)
{
int[] arr = {23,45,5,1,2,34};

for(int num:arr)//foreach
{
sop(num);
}

List<String> list = new ArrayList<String>();

list.add("oewuro");
list.add("dfhfgh");
list.add("yuiyuiyuiyui");
list.add("qweqweqewqeqweqwe");

for(String ss:list)
{
sop(ss.toUpperCase());
}

HashMap<String,String>  map = new HashMap<String,String>();
map.put("001","lisi");
map.put("002","zhaosi");
map.put("003","liuneng");

for(String key:map.keySet())
{
String value = map.get(key);
sop(key+"="+value);
}

for(Map.Entry<String,String> en:map.entrySet())
{
String key = en.getKey();
String value  = en.getValue();

sop(key+"="+value);
}

}

public static void sop(Object obj)
{
System.out.println(obj);
}
}

/*
可变参数：必须定义在参数列表的最后

*/

class  Demo5
{
public static void main(String[] args)
{
//int[] arr={34,4,5,6,7,78};

int sum = add2("owieurio",2,3,4,5,6,7,78,89,9,9,);
sop(sum);

}
//使用可变参数
public static int add2(String ss,int... arr)//把接收到的数据封装到数组中
{
int sum =0;
for(int i=0;i<arr.length;i++)
{
sum = sum+arr[i];
}

return sum;
}

public static int add(int[] arr)
{
int sum =0;
for(int i=0;i<arr.length;i++)
{
sum = sum+arr[i];
}
return sum;
}

public static int add(int a,int b)
{
return a+b;
}

public static int add(int a,int b,int c)
{
return a+b+c;
}

public static void sop(Object obj)
{
System.out.println(obj);
}
}

//静态导入
import java.util.*;
import static java.util.Arrays.*;
class Demo6
{
public static void main(String[] args)
{
int[] arr = {34,23,56,78,9};
java.util.Arrays.sort(arr);//类名相同了，包名不能省略

binarySearch(arr,78);

System.out.println(Arrays.toString(arr));//方法名相同了，类名不能省略
}
}

class Arrays
{
}

import java.util.*;
class Demo7
{
public static void main(String[] args)
{
//得到系统属性，存储到Properties集合中

Properties  pro = System.getProperties();
sop(pro);

Set<String> keys = pro.stringPropertyNames();

for(String key:keys)
{
String value = pro.getProperty(key);//根据键获取值

sop(key+"="+value);
}

pro.setProperty("user.language","USA");

Set<String> keys2 = pro.stringPropertyNames();

for(String key:keys2)
{
String value = pro.getProperty(key);//根据键获取值

sop(key+"="+value);
}
}

public static void sop(Object obj)
{
System.out.println(obj);
}
}

//每个程序在运行时都有一个运行时类对象
import java.io.*;
class  Demo8
{
public static void main(String[] args) throws IOException
{
Runtime  runtime = Runtime.getRuntime();

runtime.exec("notepad C:\\Users\\qq\\Desktop\\day03.txt");
}
}

class Node
{
private int i;
private int j;

public Node(){}
public Node(int i,int j)
{   super();
this.i = i;
this.j = j;
}

public int hashCode()
{
return (i<<16)|j;
}

public boolean equals(Object obj)
{
if(obj == null)
return false;
if(obj == this)
return true;
if(obj instanceof Node)
{
Node node =(Node)obj;
return this.i==node.i && this.j ==node.j;
}
return false;
}

public void setI(int i)
{
this.i = i;
}
public void setJ(int j)
{
this.j = j;
}
public int getI()
{
return this.i;
}
public int getJ()
{
return this.j;
}
public String toString()
{
return "["+i+","+j+"]";
}
}

import java.util.*;
class WormPanel
{
//蛇
private Worm   worm;

//食物，用set存储
private Set<Node>  foods = new HashSet<Node>();

//行数
private int rows = 10;

//列数
private int cols = 32;

public WormPanel()
{
worm = new Worm();
initFood(5);
}

public Worm  getWorm()
{
return this.worm;
}
//打印界面功能

public void print()
{
for(int i=0;i<rows;i++)
{
for(int j=0;j<cols;j++)
{
if(i==0 || i==rows-1)
System.out.print("-");
else if(j==0 || j==cols-1)
System.out.print("|");
else if(worm.contains(i,j))
System.out.print("#");
else if(foods.contains(new Node(i,j)))
System.out.print("0");
else
System.out.print(" ");

}
System.out.println();
}
}

//生成食物的方法
public void initFood(int count)
{
//随机生成食物的坐标
Random r = new Random();
while(true)
{
int i = r.nextInt(rows-2)+1;
int j = r.nextInt(cols-2)+1;

Node node =  new Node(i,j);
if(worm.contains(i,j))
{
continue;
}
foods.add(node);//不能添加重复坐标
if(foods.size()==count)
break;
}
}

public  class Worm
{
//存储构成蛇的坐标的集合
private LinkedList<Node> nodes = new LinkedList<Node>();

//方向
private int direction;

public static final  int UP = -10;
public static final  int DOWN = 10;
public static final  int LEFT = -1;
public static final  int RIGHT = 1;

public Worm()
{
nodes.add(new Node(3,9));
nodes.add(new Node(4,9));
nodes.add(new Node(5,9));
nodes.add(new Node(5,10));
nodes.add(new Node(5,11));
nodes.add(new Node(6,11));
nodes.add(new Node(7,11));
this.direction = RIGHT;//默认向右走
}

//向前走一步
public void step()
{
//先得到头结点
Node head = nodes.getFirst();
int i = head.getI()+direction/10;
int j = head.getJ()+direction%10;
//加入到头部的新结点
head = new Node(i,j);

nodes.addFirst(head);
//如果从食物集合中删除食物结点成功，说明遇到了食物
if(foods.remove(head))
{
return;
}
//删除蛇的尾部结点
nodes.removeLast();

}

public void step(int direction)
{
if(this.direction+direction==0)
throw new RuntimeException("不能掉头");
this.direction = direction;
step();
}

//判断是否包含某个坐标的方法
public boolean contains(int i,int j)
{
return nodes.contains(new Node(i,j));
}

}

}

import java.util.Scanner;
class WormTest
{
public static void main(String[] args)
{
WormPanel  panel = new WormPanel();
WormPanel.Worm  worm = panel.getWorm();
Scanner sc = new Scanner(System.in);

while(true)
{
panel.print();

String str = sc.nextLine();

if("u".equalsIgnoreCase(str))
worm.step(WormPanel.Worm.UP);
else if("d".equalsIgnoreCase(str))
worm.step(WormPanel.Worm.DOWN);
else if("l".equalsIgnoreCase(str))
worm.step(WormPanel.Worm.LEFT);
else if("r".equalsIgnoreCase(str))
worm.step(WormPanel.Worm.RIGHT);
else if("q".equalsIgnoreCase(str))
{
System.out.println("baibai");
break;
}
else
worm.step();
}

}
}