JAVA-day08 上午-集合零散知识、集合实现贪吃蛇_java集合贪吃蛇node worm wormpane-优快云博客

本文链接：https://blog.youkuaiyun.com/lc635408136/article/details/42003285

本文介绍Java中数组与集合的基本操作，包括数组与集合的转换、集合排序及遍历，并通过一个贪吃蛇游戏实例展示集合的具体应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

/*
工具类：
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();
		}


	}
}