我要评论string str2 = “come”;
arraylist list1 = new arraylist<>();
for (int i = 0; i < str1.length(); i++) {
char ch = str1.charat(i);
if(!str2.contains(ch+“”)){
list1.add(ch);
}
}
for (char ch : list1 ) {
system.out.print(ch);
}
}
运行结果:
import java.util.arraylist;
import java.util.list;
import java.util.random;
class card{
private int rank;
private string suit;
public card(int rank, string suit) {
this.rank = rank;
this.suit = suit;
}
public int getrank() {
return rank;
}
public void setrank(int rank) {
this.rank = rank;
}
public string getsuit() {
return suit;
}
public void setsuit(string suit) {
this.suit = suit;
}
@override
public string tostring() {
return “{” + suit + “->” +rank + “}”;
}
}
public class test {
private static final string[] suits = {“❤”,“♠”,“♣”,“♦”};
/**
-
构造一副牌
-
@return
*/
public static list buycard(){
arraylist cards = new arraylist<>();
//四种花色
for (int i = 0; i < 4; i++) {
//每个花色13张牌
for (int j = 0; j < 13; j++) {
/*string suit = suits[i];//花色
int rank = j ;//牌数
card card = new card(rank,suit);//得到一张牌card
cards.add(card);*/
cards.add(new card(j,suits[i]));//优化后的代码
}
}
return cards;
}
private static void swap(list cards,int i,int j){
card tmp = cards.get(i);
cards.set(i,cards.get(j));
cards.set(j,tmp);
}
/**
-
洗牌
-
@param cards
*/
public static void shuffle(list cards){
int size = cards.size();
for (int i = size - 1; i > 0; i–) {
random random = new random();
int rand = random.nextint(i);
swap(cards,i,rand);
}
}
public static void main(string[] args) {
list cards = buycard();
system.out.println(“刚开始的牌:”+cards);
shuffle(cards);
system.out.println(“洗过后的牌:”+cards);
arraylist<list> hand = new arraylist<>();
list hand1 = new arraylist<>();
list hand2 = new arraylist<>();
list hand3 = new arraylist<>();
hand.add(hand1);
hand.add(hand2);
hand.add(hand3);
//每个人,轮流揭牌
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 3; j++) {
card card = cards.remove(0);//拿一张牌 少一张牌 remov去掉
hand.get(j).add(card);
}
}
system.out.println("第1个人的牌: "+hand1);
system.out.println("第2个人的牌: "+hand2);
system.out.println("第3个人的牌: "+hand3);
system.out.println("剩余的排: "+cards);
}
}
=====================================================================================
package demo;
import java.util.arrays;
class myarraylist {
private object[] elem;//数组
private int usedsize;//代表有效数据个数
private static final object[] defaultcapacity_empty_elementdata = {};
public myarraylist() {
this.elem = defaultcapacity_empty_elementdata;
}
public myarraylist(int capacity) {
//对参数进行一个判断
if (capacity > 0) {
this.elem = new object[capacity];
} else if (capacity == 0) {
this.elem = new object[0];
} else {
throw new illegalargumentexception(“不能为负数!”);
}
}
/**
-
尾插 e
-
@param e
-
@return
*/
public boolean add(e e) {
//缺点一个真正的容量.扩容
ensurecapacityinternal(usedsize + 1);
elem[usedsize] = e;
usedsize++;
return true;
}
private void ensurecapacityinternal(int mincapacity) {
//计算出需要的容量
int capacity = calculatecapacity(elem, mincapacity);
//拿着计算出的容量,去判断是否扩容,需要扩容就扩容
ensureexplicitcapacity(capacity);
}
private static int calculatecapacity(object[] elem, int mincapacity) {
//1.是否elem数组分配过大小
if (elem == defaultcapacity_empty_elementdata) {
return math.max(10, mincapacity);
}
//2.分配过 就返回+1的值
return mincapacity;
}
private void ensureexplicitcapacity(int mincapacity) {
if (mincapacity - elem.length > 0) {
//扩容
grow(mincapacity);
}
}
private static final int max_array_size = integer.max_value - 8;
private void grow(int mincapacity) {
int oldcapacity = elem.length;
int newcapacity = oldcapacity + (oldcapacity >> 1);//1.5倍扩容
if (newcapacity - mincapacity < 0)
newcapacity = mincapacity;
if (newcapacity - max_array_size > 0)
//说明需要的容量非常大
newcapacity = hugecapacity(mincapacity);
elem = arrays.copyof(elem, newcapacity);
}
private static int hugecapacity(int mincapacity) {
if (mincapacity < 0)
throw new outofmemoryerror();
return (mincapacity > max_array_size) ?
integer.max_value :
max_array_size;
}
/**
-
将 e 插入到 index 位置
-
@param index
-
@param e
*/
public void add(int index, e e) {
rangecheckforadd(index);
ensurecapacityinternal(usedsize + 1);
copy(index, e);
usedsize++;
}
private void copy(int index, e e) {
for (int i = usedsize - 1; i >= index; i–) {
elem[i + 1] = elem[i];
}
elem[index] = e;
}
/**
-
判断index位置是否合法
-
@param index
*/
public void rangecheckforadd(int index) {
if (index < 0 || index > size()) {
throw new indexoutofboundsexception(“index位置不合法无法插入”);
}
}
/**
-
获取顺序表的大小
-
@return
*/
public int size() {
return this.usedsize;
}
/**
-
获取o第一次出现的位置
-
@param o
-
@return
*/
public int indexof(object o) {
if (null == o) {
for (int i = 0; i < usedsize; i++) {
if (elem[i] == null) {
return i;
}
}
} else {
for (int i = 0; i < usedsize; i++) {
if (elem[i].equals(o)) {
return i;
}
}
}
return -1;
}
/**
-
删出第一次出现的e
-
@param o
-
@return
*/
public boolean remove(object o) {
int index = indexof(o);
if (index == -1) {
return false;
}
remove(index);
return true;
}
/**
-
删除index位置上元素
-
@param index
-
@return
*/
public e remove(int index) {
rangecheckforadd(index);
e e = (e) elem[index];
// 将index之后的元素统一往前搬移一个位置
for (int i = index; i < usedsize - 1; ++i) {
elem[i] = elem[i + 1];
}
elem[usedsize] = null;
usedsize–;
return e;
}
/**
-
获取index位置上的元素
-
@param index
-
@return
*/
public e get(int index) {
rangecheckforadd(index);
return (e) elem[index];
}
/**
-
将index位置上元素设置为e
-
@param index
-
@param e
-
@return
*/
public e set(int index, e e) {
rangecheckforadd(index);
elem[index] = e;
return e;
}
/**
- 清空
*/
public void clear() {
for (int i = 0; i < usedsize; i++) {
elem[i] = null;
}
usedsize = 0;
}
@override
public string tostring() {
string s = “[”;
if (usedsize > 0) {
for (int i = 0; i < usedsize - 1; i++) {
s += elem[i];
s += ", ";
}
s += elem[usedsize - 1];
}
s += “]”;
return s;
}
}
public class main {
public static void main(string[] args) {
myarraylist list = new myarraylist<>();
list.add(“q”);
list.add(“w”);
list.add(“e”);
list.add(“r”);
list.add(“t”);
system.out.println(list);
system.out.println(list.indexof(“r”));
system.out.println(list.get(1));
system.out.println(list.set(5, “666”));
list.clear();
system.out.println(list);
}
}
运行结果:
==============================================================================
leetcode 118:杨辉三角
描述:
给定一个非负整数 numrows，生成「杨辉三角」的前 numrows 行。
在「杨辉三角」中，每个数是它左上方和右上方的数的和。
解题思路:
1.第一行永远为1,提前让第一行为1.
2.从第二行开始,首尾都是1,中间的是由上一层该位置和前一个位置的和组成
3.杨辉三角每一层数的个数和层数相同
画图解析:
public list<list> generate(int numrows) {
list<list> ret = new arraylist<>();
//第一行 永远为1的情况:
list list1 = new arraylist<>();
list1.add(1);
ret.add(list1);
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、oppo等大厂，18年进入阿里一直到现在。
深知大多数java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上java开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
如果你觉得这些内容对你有帮助，可以扫码获取！！（备注java获取）
笔者福利
以下是小编自己针对马上即将到来的金九银十准备的一套“面试宝典”，不管是技术还是hr的问题都有针对性的回答。
有了这个，面试踩雷？不存在的！
回馈粉丝，诚意满满！！！
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》
大家的负担。**[外链图片转存中…(img-c2l6w60u-1712937238403)]
[外链图片转存中…(img-xnzore2j-1712937238404)]
[外链图片转存中…(img-rdfh1azg-1712937238404)]
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上java开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
如果你觉得这些内容对你有帮助，可以扫码获取！！（备注java获取）
笔者福利
以下是小编自己针对马上即将到来的金九银十准备的一套“面试宝典”，不管是技术还是hr的问题都有针对性的回答。
有了这个，面试踩雷？不存在的！
回馈粉丝，诚意满满！！！
[外链图片转存中…(img-odru54ex-1712937238404)]
[外链图片转存中…(img-gs9ihoub-1712937238404)]
[外链图片转存中…(img-265ejuho-1712937238405)]
[外链图片转存中…(img-2k8fnwnd-1712937238405)]
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》
发表评论