慕课网

精品课程 Java入门第三季

Java入门第三季

最热最新

清波SS

//将基本类型转化为字符串
int c=10;
String str1=Integer.toString(c);
String str2=string.valueOf(c);
String str3=c+"";
//将字符串转为基本类型
String str="8";
int a1=Integer.parseInt(str);
int a2=Interger.valueOf(str);

查看全部

0 采集收起来源：Java 中基本类型和字符串之间的转换
2018-07-23
曼走丶999

异常种类分为

查看全部

0 采集收起来源：Java异常简介
2018-07-23
清波SS

StringBuffer ：线性安全
StringBuilder ：性能略高，一般优先使用。

查看全部

0 采集收起来源：认识 Java 中的 StringBuilder 类
2018-07-22
清波SS

多次出现的字符常量，Java 编译程序只创建一个。

查看全部

0 采集收起来源：Java 中字符串的不变性
2018-07-22

慕仔2498183

/*介绍一个本人认为挺好理解的方法*/

public class HelloWorld
 {    
 public static void main(String[] args) {  
 // 创建一个空的StringBuilder对象 
  StringBuilder str =new StringBuilder("");          
  // 追加字符串  
  str.append("jaewkjldfxmopzdm");          
  // 从后往前每隔三位插入逗号        
  int n =str.length();        
  int count =0 ;       
  /*定义插入逗号的次数*/  
        
  if(str.length()%3==0)  
    {
     count =(n/3)-1;    
  //次数减1，假设n=9，那么插入的次数是否为 2  而不是 3 ？ 凡是余数为0的字符长度 插入逗号的次数都要减一
    }
   else        
    {           
     count =(n/3);
    }        
        for(int i=0; i<count; i++)  //插入       
         {
                     n=n-3;
                     str.insert(n,",");
         } 
 // 将StringBuilder对象转换为String对象并输出  
 System.out.println(str.toString());  
 System.out.println("插入次数:"+count); 
 }
 }

显示timeout的话再再提交一遍就好了

查看全部

1 采集收起来源：Java 中的 StringBuilder 类的常用方法

2018-07-22

快乐的汽水

map接口提供了一种映射关系，其中的元素是以键值对（key- value)的行摄存储的，能够实现根据key快速查找value
map中的键值对以entry类型的对象实例形式存在
键不可以重复，value值可以
map 集合的实现类是hasmap 类
HashMap中的Entry对象是无序排列的
key值和value值都可以为null,但是一个HashMap只能有一个key值为null的映射（key值不可重复）

查看全部

0 采集收起来源：Map & HashMap 简介
2018-07-21
风间梦叶

charAt截取的字符是char类型的，不能用equals和字符比较

查看全部

0 采集收起来源：Java 中的 String 类常用方法 Ⅱ
2018-07-21
江户川柯南_qq 12:43

Collections.soft(),先数字，后字母，先大写后小写

查看全部

0 采集收起来源：应用 Collections.sort() 实现 List 排序
2018-07-21
快乐的汽水

在泛型类型集合中，不仅可以存放泛型类型的对象还可以存放泛型类型的子类型对象。

查看全部

0 采集收起来源：学生选课---应用泛型管理课程 Ⅱ
2018-07-20
快乐的汽水

集合中的元素，可以是任意类型的对象（对象的引用）
如果把某个对象放入集合，则会忽他的类型，
而把他当作Object处理
泛型则是规定了某个集合只可以存放特定类型的对象
会在编译期间进行类型检查

查看全部

0 采集收起来源：学生选课---应用泛型管理课程 Ⅰ
2018-07-20
我不是个乖小孩

捕获自定义异常，并变成运行时异常

查看全部

0 采集收起来源：Java 中的异常链
2018-07-20
我不是个乖小孩

java抛出异常

查看全部

0 采集收起来源：Java 中的异常抛出以及自定义异常
2018-07-20
成功入行的秃头少女丶 04:51

List集合可以储存泛型的子类对象。

复习：当父类含有有参构造器没有无参构造器时，子类继承时必须调用父类的有参构造器。

泛型必须为包装类型，比如Int的包装类型Integer。但Int不行

查看全部

0 采集收起来源：学生选课---应用泛型管理课程 Ⅱ
2018-07-20
我不是个乖小孩

java异常

检查异常要自己手动添加捕获语句

查看全部

0 采集收起来源：Java异常简介
2018-07-20
一直走下去吧 05:41

package com.imooc.pkgame;

import java.awt.PointerInfo;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Random;
import java.util.Set;

/**
* game类
* @author zty
*
*/
public class Game {

public static void main(String[] args) {

// 创建扑克牌
Game game = new Game();
game.createPokers();
game.sendPoker();

}
/**
* 创建牌
*/
public void createPokers() {
System.out.println("开始创建一副pokers...");
// 外层point，内层花色
for (int i = 3; i < 18; i++) {
if(i > 15) {
Poker pk = new Poker(i, 5);
pokerList.add(pk);
}else {
for (int j = 1; j < 5; j++) {
Poker pk = new Poker(i,j);
// 加入到list中
pokerList.add(pk);
}
}

}
// 遍历输出所有poker
Iterator<Poker>it = pokerList.iterator();

while(it.hasNext()) {
Poker pk = it.next();
System.out.print(pk.toString());
}
System.out.println();
}
/**
* 开始洗牌
* 创建玩家
* 然后发牌
*
*/
public void sendPoker() {
System.out.println("正在创建玩家...");
Player p1 = new Player(1, "玩家1号");
Player p2 = new Player(2, "玩家2号");
System.out.println("开始洗牌...");
Collections.shuffle(pokerList);
System.out.println("洗牌结束...");
System.out.println("开始发牌...");
System.out.print(p1.name+":");
p1.havePoker.add(pokerList.get(0));
System.out.print(p1.havePoker.get(0).toString());
p1.havePoker.add(pokerList.get(2));
System.out.println(p1.havePoker.get(1).toString());
System.out.print(p2.name+":");
p2.havePoker.add(pokerList.get(1));
System.out.print(p2.havePoker.get(0).toString());
p2.havePoker.add(pokerList.get(3));
System.out.println(p2.havePoker.get(1).toString());

Player p = comparePoker(p1, p2);
System.out.print("获胜的是："+p.name);

}

/**
*比较大小 ,比较的是两个玩家手牌(Poker对象大小)大小
*/
public static Player comparePoker(Player p1, Player p2) {

for (int i = 0; i < p1.havePoker.size(); i++) {
for (int j = 0; j < p2.havePoker.size(); j++) {
if(p1.havePoker.get(i).compareTo(p2.havePoker.get(j)) > 0) {
return p1;
}
}
}
return p2;
}

private List<Poker> pokerList;
public Game() {
System.out.println("Game Start:");
this.pokerList = new ArrayList<Poker>();
}

}

/**
* poker类
*/
class Poker implements Comparable<Poker>{
Integer pointNumber;
Integer flowerColorNumber;
Map<Integer,String> point;//点数大小和样式
Map<Integer,String> flowerColor ;//花色大小和样式
Map<String,String>poker;//扑克点数样式和花色

/**
* 构造器初始化 point和flowercolor
*/
private Poker() {
this.point = new HashMap<Integer,String>();
point.put(Constant.TWO, Constant.TWO_STRING);
point.put(Constant.THREE, Constant.THREE_STRING);
point.put(Constant.FOUR, Constant.FOUR_STRING);
point.put(Constant.FIVE, Constant.FIVE_STRING);
point.put(Constant.SIX, Constant.SIX_STRING);
point.put(Constant.SEVEN, Constant.SEVEN_STRING);
point.put(Constant.EIGHT, Constant.EIGHT_STRING);
point.put(Constant.NINE, Constant.NINE_STRING);
point.put(Constant.TEN, Constant.TEN_STRING);
point.put(Constant.J, Constant.J_STRING);
point.put(Constant.Q, Constant.Q_STRING);
point.put(Constant.K, Constant.K_STRING);
point.put(Constant.A, Constant.A_STRING);
point.put(Constant.SMALL, Constant.SMALL_STRING);
point.put(Constant.BIG, Constant.BIG_STRING);

this.flowerColor = new HashMap<Integer, String>();
flowerColor.put(Constant.BLANK_NUMBER, Constant.BLANK);
flowerColor.put(Constant.SPADES_NUMBER, Constant.SPADES);
flowerColor.put(Constant.HEARTS_NUMBER, Constant.HEARTS);
flowerColor.put(Constant.DIAMONDS_NUMBER, Constant.DIAMONDS);
flowerColor.put(Constant.CLUBS_NUMBER, Constant.CLUBS);
this.poker = new HashMap<String,String>();

}
/**
* 构造器初始化poker
* @param pointNumber
* @param flowerColor
*/
public Poker(Integer pointNumber, Integer flowerColor) {
this();
this.pointNumber = pointNumber;
this.flowerColorNumber = flowerColor;
poker.put(point.get(pointNumber), this.flowerColor.get(flowerColor));
}

/**
* 输出poker的信息
*/

@Override
public String toString() {
Set<Entry<String, String>> entry = poker.entrySet();
StringBuilder strb = new StringBuilder();
for (Entry<String, String> entry2 : entry) {
String str = entry2.getValue()+entry2.getKey();
strb.append(str+"\t");
}
String str1 = strb.toString();
return str1;
}
/**
* 比较点数大小重写comparaeTo
*/
@Override
public int compareTo(Poker o) {
if(this.pointNumber > o.pointNumber) {
return 1;
}else if(this.pointNumber < o.pointNumber) {
return -1;
}else {
if (this.flowerColorNumber > o.flowerColorNumber) {
return 1;
} else {
return -1;
}
}

}

}

/**
* 玩家类
*/
class Player{
int id;
String name;
List<Poker> havePoker ;
public Player(int id, String name) {
super();
this.id = id;
this.name = name;
this.havePoker = new ArrayList<Poker>();
}

}

/**
* constant类
*/
class Constant{
/**
* 花色
*/
static final Integer BLANK_NUMBER = 5;
static final Integer SPADES_NUMBER = 4;
static final Integer HEARTS_NUMBER = 3;
static final Integer CLUBS_NUMBER = 2;
static final Integer DIAMONDS_NUMBER = 1;
static final String BLANK = "";
static final String SPADES = "黑桃";
static final String HEARTS = "红心";
static final String CLUBS = "梅花";
static final String DIAMONDS = "方块";
/**
* 点数
*/
static final Integer TWO = 15;
static final Integer THREE = 3;
static final Integer FOUR = 4;
static final Integer FIVE = 5;
static final Integer SIX = 6;
static final Integer SEVEN = 7;
static final Integer EIGHT = 8;
static final Integer NINE = 9;
static final Integer TEN = 10;
static final Integer J = 11;
static final Integer Q = 12;
static final Integer K = 13;
static final Integer A = 14;
static final Integer SMALL = 16;
static final Integer BIG = 17;
static final String TWO_STRING = "2";
static final String THREE_STRING = "3";
static final String FOUR_STRING = "4";
static final String FIVE_STRING = "5";
static final String SIX_STRING = "6";
static final String SEVEN_STRING = "7";
static final String EIGHT_STRING = "8";
static final String NINE_STRING = "9";
static final String TEN_STRING = "10";
static final String J_STRING = "J";
static final String Q_STRING = "Q";
static final String K_STRING = "K";
static final String A_STRING = "A";
static final String SMALL_STRING = "小王";
static final String BIG_STRING = "大王";
}

查看全部

1 采集收起来源：简易扑克牌游戏
2018-07-20

首页上一页 288 289 290 291 292 293 294 下一页尾页

0/150

提交

取消

开始学习

课程须知: 此部分为 Java 课程的进阶内容，适合具有一定 Java 基础的伙伴们学习，如果您是新手，建议您移步《Java入门第一季》和《Java入门第二季》，在理解并掌握面向对象相关知识后再回来进修。

老师告诉你能学到什么？: 本课程将学习 Java 中的异常处理、集合框架、字符串、常用类等，逐步学习掌握 Java 高级技术。